Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r51859 - in sandbox/numeric_bindings/boost/numeric/bindings/lapack: . computational driver
From: rutger_at_[hidden]
Date: 2009-03-19 15:51:29


Author: rutger
Date: 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
New Revision: 51859
URL: http://svn.boost.org/trac/boost/changeset/51859

Log:
Fixed default argument for function templates of lapack low-level routines

Added:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/keywords.hpp (contents, props changed)
Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp | 25 +++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp | 36 +++++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp | 41 ++++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp | 33 +++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp | 25 +++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp | 16 ++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 21 ++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 37 +++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp | 24 +++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 49 ++++++++++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 27 +++++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp | 25 +++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp | 21 ++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp | 18 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp | 6 ++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 17 +++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 27 ++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp | 33 +++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp | 37 ++++++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp | 33 ++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp | 44 +++++++++++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp | 38 ++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp | 19 ++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp | 41 ++++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp | 44 +++++++++++++++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp | 38 ++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp | 53 +++++++++++++++++++++++++++++++++++++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 20 ++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp | 28 +++++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp | 25 ++++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 23 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp | 3 ++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 24 ++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 24 ++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 22 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp | 25 ++++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 23 +++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 19 +++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp | 4 +++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 24 ++++++++++++++++-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp | 16 +++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp | 22 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp | 15 ++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp | 21 +++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 17 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp | 23 ++++++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp | 18 ++++++++++++
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 24 ++++++++++++++++-
   229 files changed, 3676 insertions(+), 247 deletions(-)

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSDC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixU,
@@ -135,7 +138,7 @@
         typename Workspace >
 inline integer_t bdsdc( char const uplo, char const compq,
         integer_t const n, VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt,
- VectorQ& q, VectorIQ& iq, Workspace work = optimal_workspace() ) {
+ VectorQ& q, VectorIQ& iq, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     bdsdc_impl< value_type >::compute( uplo, compq, n, d, e, u, vt, q,
@@ -143,6 +146,19 @@
     return info;
 }
 
+// template function to call bdsdc, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixU,
+ typename MatrixVT, typename VectorQ, typename VectorIQ >
+inline integer_t bdsdc( char const uplo, char const compq,
+ integer_t const n, VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt,
+ VectorQ& q, VectorIQ& iq ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ bdsdc_impl< value_type >::compute( uplo, compq, n, d, e, u, vt, q,
+ iq, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -81,6 +83,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
@@ -155,6 +158,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
@@ -225,8 +229,7 @@
 template< typename VectorD, typename VectorE, typename MatrixVT,
         typename MatrixU, typename MatrixC, typename Workspace >
 inline integer_t bdsqr( char const uplo, integer_t const n, VectorD& d,
- VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     bdsqr_impl< value_type >::compute( uplo, n, d, e, vt, u, c, info,
@@ -234,6 +237,18 @@
     return info;
 }
 
+// template function to call bdsqr, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixVT,
+ typename MatrixU, typename MatrixC >
+inline integer_t bdsqr( char const uplo, integer_t const n, VectorD& d,
+ VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ bdsqr_impl< value_type >::compute( uplo, n, d, e, vt, u, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBBRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
@@ -164,6 +167,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
@@ -251,7 +255,7 @@
 inline integer_t gbbrd( char const vect, integer_t const m,
         integer_t const n, integer_t const kl, integer_t const ku,
         MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, MatrixPT& pt,
- MatrixC& c, Workspace work = optimal_workspace() ) {
+ MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     gbbrd_impl< value_type >::compute( vect, m, n, kl, ku, ab, d, e, q,
@@ -259,6 +263,20 @@
     return info;
 }
 
+// template function to call gbbrd, default workspace type
+template< typename MatrixAB, typename VectorD, typename VectorE,
+ typename MatrixQ, typename MatrixPT, typename MatrixC >
+inline integer_t gbbrd( char const vect, integer_t const m,
+ integer_t const n, integer_t const kl, integer_t const ku,
+ MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, MatrixPT& pt,
+ MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ gbbrd_impl< value_type >::compute( vect, m, n, kl, ku, ab, d, e, q,
+ pt, c, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -77,6 +79,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
@@ -139,6 +143,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
@@ -202,7 +208,7 @@
         integer_t const kl, integer_t const ku, MatrixAB& ab,
         VectorIPIV& ipiv, typename traits::matrix_traits<
         MatrixAB >::value_type const anorm, typename traits::matrix_traits<
- MatrixAB >::value_type& rcond, Workspace work = optimal_workspace() ) {
+ MatrixAB >::value_type& rcond, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     gbcon_impl< value_type >::compute( norm, n, kl, ku, ab, ipiv, anorm,
@@ -210,6 +216,20 @@
     return info;
 }
 
+// template function to call gbcon, default workspace type
+template< typename MatrixAB, typename VectorIPIV >
+inline integer_t gbcon( char const norm, integer_t const n,
+ integer_t const kl, integer_t const ku, MatrixAB& ab,
+ VectorIPIV& ipiv, typename traits::matrix_traits<
+ MatrixAB >::value_type const anorm, typename traits::matrix_traits<
+ MatrixAB >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ gbcon_impl< value_type >::compute( norm, n, kl, ku, ab, ipiv, anorm,
+ rcond, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBEQU_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorR, typename VectorC >
@@ -103,6 +106,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorR, typename VectorC >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -89,6 +91,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
@@ -184,6 +188,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
@@ -278,7 +284,7 @@
 inline integer_t gbrfs( char const trans, integer_t const n,
         integer_t const kl, integer_t const ku, MatrixAB& ab, MatrixAFB& afb,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     gbrfs_impl< value_type >::compute( trans, n, kl, ku, ab, afb, ipiv,
@@ -286,6 +292,21 @@
     return info;
 }
 
+// template function to call gbrfs, default workspace type
+template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t gbrfs( char const trans, integer_t const n,
+ integer_t const kl, integer_t const ku, MatrixAB& ab, MatrixAFB& afb,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ gbrfs_impl< value_type >::compute( trans, n, kl, ku, ab, afb, ipiv,
+ b, x, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -66,6 +68,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAK_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorSCALE, typename MatrixV >
@@ -103,6 +106,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorSCALE, typename MatrixV >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -67,6 +69,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorSCALE >
@@ -91,6 +94,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorSCALE >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -77,6 +79,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
@@ -158,6 +161,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
@@ -235,14 +239,25 @@
 template< typename MatrixA, typename VectorD, typename VectorE,
         typename VectorTAUQ, typename VectorTAUP, typename Workspace >
 inline integer_t gebrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup,
- Workspace work = optimal_workspace() ) {
+ VectorTAUQ& tauq, VectorTAUP& taup, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gebrd_impl< value_type >::compute( a, d, e, tauq, taup, info, work );
     return info;
 }
 
+// template function to call gebrd, default workspace type
+template< typename MatrixA, typename VectorD, typename VectorE,
+ typename VectorTAUQ, typename VectorTAUP >
+inline integer_t gebrd( MatrixA& a, VectorD& d, VectorE& e,
+ VectorTAUQ& tauq, VectorTAUP& taup ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gebrd_impl< value_type >::compute( a, d, e, tauq, taup, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GECON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
@@ -128,6 +131,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
@@ -183,7 +187,7 @@
 inline integer_t gecon( char const norm, MatrixA& a,
         typename traits::matrix_traits< MatrixA >::value_type const anorm,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gecon_impl< value_type >::compute( norm, a, anorm, rcond, info,
@@ -191,6 +195,18 @@
     return info;
 }
 
+// template function to call gecon, default workspace type
+template< typename MatrixA >
+inline integer_t gecon( char const norm, MatrixA& a,
+ typename traits::matrix_traits< MatrixA >::value_type const anorm,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gecon_impl< value_type >::compute( norm, a, anorm, rcond, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEEQU_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -67,6 +69,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorR, typename VectorC >
@@ -96,6 +99,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorR, typename VectorC >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEHRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -74,6 +76,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -130,6 +133,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -184,13 +188,24 @@
 // template function to call gehrd
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t gehrd( integer_t const ilo, integer_t const ihi,
- MatrixA& a, VectorTAU& tau, Workspace work = optimal_workspace() ) {
+ MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gehrd_impl< value_type >::compute( ilo, ihi, a, tau, info, work );
     return info;
 }
 
+// template function to call gehrd, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t gehrd( integer_t const ilo, integer_t const ihi,
+ MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gehrd_impl< value_type >::compute( ilo, ihi, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GELQF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -72,6 +74,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -130,6 +133,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -185,14 +189,23 @@
 
 // template function to call gelqf
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t gelqf( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t gelqf( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gelqf_impl< value_type >::compute( a, tau, info, work );
     return info;
 }
 
+// template function to call gelqf, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t gelqf( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gelqf_impl< value_type >::compute( a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQLF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -72,6 +74,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -130,6 +133,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -185,14 +189,23 @@
 
 // template function to call geqlf
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t geqlf( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t geqlf( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geqlf_impl< value_type >::compute( a, tau, info, work );
     return info;
 }
 
+// template function to call geqlf, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t geqlf( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geqlf_impl< value_type >::compute( a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQP3_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -74,6 +76,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU,
@@ -134,6 +137,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU,
@@ -205,13 +209,23 @@
 template< typename MatrixA, typename VectorJPVT, typename VectorTAU,
         typename Workspace >
 inline integer_t geqp3( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geqp3_impl< value_type >::compute( a, jpvt, tau, info, work );
     return info;
 }
 
+// template function to call geqp3, default workspace type
+template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
+inline integer_t geqp3( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geqp3_impl< value_type >::compute( a, jpvt, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -72,6 +74,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -130,6 +133,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -185,14 +189,23 @@
 
 // template function to call geqrf
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t geqrf( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t geqrf( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geqrf_impl< value_type >::compute( a, tau, info, work );
     return info;
 }
 
+// template function to call geqrf, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t geqrf( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geqrf_impl< value_type >::compute( a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -180,6 +184,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -273,7 +279,7 @@
         typename VectorBERR, typename Workspace >
 inline integer_t gerfs( char const trans, MatrixA& a, MatrixAF& af,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gerfs_impl< value_type >::compute( trans, a, af, ipiv, b, x, ferr,
@@ -281,6 +287,20 @@
     return info;
 }
 
+// template function to call gerfs, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t gerfs( char const trans, MatrixA& a, MatrixAF& af,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gerfs_impl< value_type >::compute( trans, a, af, ipiv, b, x, ferr,
+ berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERQF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -72,6 +74,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -130,6 +133,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -185,14 +189,23 @@
 
 // template function to call gerqf
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t gerqf( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t gerqf( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gerqf_impl< value_type >::compute( a, tau, info, work );
     return info;
 }
 
+// template function to call gerqf, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t gerqf( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gerqf_impl< value_type >::compute( a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -56,6 +58,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorIPIV >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -70,6 +72,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -122,6 +126,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -171,14 +177,23 @@
 
 // template function to call getri
 template< typename MatrixA, typename VectorIPIV, typename Workspace >
-inline integer_t getri( MatrixA& a, VectorIPIV& ipiv,
- Workspace work = optimal_workspace() ) {
+inline integer_t getri( MatrixA& a, VectorIPIV& ipiv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     getri_impl< value_type >::compute( a, ipiv, info, work );
     return info;
 }
 
+// template function to call getri, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t getri( MatrixA& a, VectorIPIV& ipiv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ getri_impl< value_type >::compute( a, ipiv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -63,6 +65,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAK_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorLSCALE, typename VectorRSCALE, typename MatrixV >
@@ -109,6 +112,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorLSCALE, typename VectorRSCALE, typename MatrixV >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -77,6 +79,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
@@ -141,6 +145,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
@@ -202,7 +208,7 @@
         typename VectorRSCALE, typename Workspace >
 inline integer_t ggbal( char const job, integer_t const n, MatrixA& a,
         MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, Workspace work = optimal_workspace() ) {
+ VectorRSCALE& rscale, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggbal_impl< value_type >::compute( job, n, a, b, ilo, ihi, lscale,
@@ -210,6 +216,19 @@
     return info;
 }
 
+// template function to call ggbal, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
+ typename VectorRSCALE >
+inline integer_t ggbal( char const job, integer_t const n, MatrixA& a,
+ MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggbal_impl< value_type >::compute( job, n, a, b, ilo, ihi, lscale,
+ rscale, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGHRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -72,6 +74,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGQRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
@@ -160,6 +164,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
@@ -237,13 +243,25 @@
 template< typename MatrixA, typename VectorTAUA, typename MatrixB,
         typename VectorTAUB, typename Workspace >
 inline integer_t ggqrf( MatrixA& a, VectorTAUA& taua, MatrixB& b,
- VectorTAUB& taub, Workspace work = optimal_workspace() ) {
+ VectorTAUB& taub, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggqrf_impl< value_type >::compute( a, taua, b, taub, info, work );
     return info;
 }
 
+// template function to call ggqrf, default workspace type
+template< typename MatrixA, typename VectorTAUA, typename MatrixB,
+ typename VectorTAUB >
+inline integer_t ggqrf( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ VectorTAUB& taub ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggqrf_impl< value_type >::compute( a, taua, b, taub, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGRQF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
@@ -160,6 +164,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
@@ -237,13 +243,25 @@
 template< typename MatrixA, typename VectorTAUA, typename MatrixB,
         typename VectorTAUB, typename Workspace >
 inline integer_t ggrqf( MatrixA& a, VectorTAUA& taua, MatrixB& b,
- VectorTAUB& taub, Workspace work = optimal_workspace() ) {
+ VectorTAUB& taub, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggrqf_impl< value_type >::compute( a, taua, b, taub, info, work );
     return info;
 }
 
+// template function to call ggrqf, default workspace type
+template< typename MatrixA, typename VectorTAUA, typename MatrixB,
+ typename VectorTAUB >
+inline integer_t ggrqf( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ VectorTAUB& taub ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggrqf_impl< value_type >::compute( a, taua, b, taub, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGSVP_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -101,6 +103,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
@@ -202,6 +206,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
@@ -315,7 +321,7 @@
         typename traits::matrix_traits< MatrixA >::value_type const tola,
         typename traits::matrix_traits< MatrixA >::value_type const tolb,
         integer_t& k, integer_t& l, MatrixU& u, MatrixV& v, MatrixQ& q,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggsvp_impl< value_type >::compute( jobu, jobv, jobq, a, b, tola,
@@ -323,6 +329,21 @@
     return info;
 }
 
+// template function to call ggsvp, default workspace type
+template< typename MatrixA, typename MatrixB, typename MatrixU,
+ typename MatrixV, typename MatrixQ >
+inline integer_t ggsvp( char const jobu, char const jobv,
+ char const jobq, MatrixA& a, MatrixB& b,
+ typename traits::matrix_traits< MatrixA >::value_type const tola,
+ typename traits::matrix_traits< MatrixA >::value_type const tolb,
+ integer_t& k, integer_t& l, MatrixU& u, MatrixV& v, MatrixQ& q ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggsvp_impl< value_type >::compute( jobu, jobv, jobq, a, b, tola,
+ tolb, k, l, u, v, q, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -94,6 +96,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,
@@ -212,6 +216,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,
@@ -331,8 +337,7 @@
 inline integer_t gtrfs( char const trans, integer_t const n,
         VectorDL& dl, VectorD& d, VectorDU& du, VectorDLF& dlf, VectorDF& df,
         VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::vector_traits< VectorDL >::value_type value_type;
     integer_t info(0);
     gtrfs_impl< value_type >::compute( trans, n, dl, d, du, dlf, df, duf,
@@ -340,6 +345,22 @@
     return info;
 }
 
+// template function to call gtrfs, default workspace type
+template< typename VectorDL, typename VectorD, typename VectorDU,
+ typename VectorDLF, typename VectorDF, typename VectorDUF,
+ typename VectorDU2, typename VectorIPIV, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t gtrfs( char const trans, integer_t const n,
+ VectorDL& dl, VectorD& d, VectorDU& du, VectorDLF& dlf, VectorDF& df,
+ VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, MatrixB& b,
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::vector_traits< VectorDL >::value_type value_type;
+ integer_t info(0);
+ gtrfs_impl< value_type >::compute( trans, n, dl, d, du, dlf, df, duf,
+ du2, ipiv, b, x, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -69,6 +71,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBGST_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -58,6 +60,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
@@ -128,7 +131,7 @@
         typename Workspace >
 inline integer_t hbgst( char const vect, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- MatrixX& x, Workspace work = optimal_workspace() ) {
+ MatrixX& x, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbgst_impl< value_type >::compute( vect, n, ka, kb, ab, bb, x, info,
@@ -136,6 +139,18 @@
     return info;
 }
 
+// template function to call hbgst, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename MatrixX >
+inline integer_t hbgst( char const vect, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ MatrixX& x ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbgst_impl< value_type >::compute( vect, n, ka, kb, ab, bb, x, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBTRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
@@ -115,7 +118,7 @@
         typename MatrixQ, typename Workspace >
 inline integer_t hbtrd( char const vect, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbtrd_impl< value_type >::compute( vect, n, kd, ab, d, e, q, info,
@@ -123,6 +126,19 @@
     return info;
 }
 
+// template function to call hbtrd, default workspace type
+template< typename MatrixAB, typename VectorD, typename VectorE,
+ typename MatrixQ >
+inline integer_t hbtrd( char const vect, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
+ MatrixQ& q ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbtrd_impl< value_type >::compute( vect, n, kd, ab, d, e, q, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HECON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -54,6 +56,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -103,7 +107,7 @@
 inline integer_t hecon( char const uplo, MatrixA& a, VectorIPIV& ipiv,
         typename traits::matrix_traits< MatrixA >::value_type const anorm,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hecon_impl< value_type >::compute( uplo, a, ipiv, anorm, rcond, info,
@@ -111,6 +115,18 @@
     return info;
 }
 
+// template function to call hecon, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t hecon( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ typename traits::matrix_traits< MatrixA >::value_type const anorm,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hecon_impl< value_type >::compute( uplo, a, ipiv, anorm, rcond, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HEGST_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -50,6 +52,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HERFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -62,6 +64,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -155,7 +159,7 @@
         typename VectorBERR, typename Workspace >
 inline integer_t herfs( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
         MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     herfs_impl< value_type >::compute( a, af, ipiv, b, x, ferr, berr,
@@ -163,6 +167,19 @@
     return info;
 }
 
+// template function to call herfs, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t herfs( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ herfs_impl< value_type >::compute( a, af, ipiv, b, x, ferr, berr,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
@@ -123,13 +126,25 @@
 template< typename MatrixA, typename VectorD, typename VectorE,
         typename VectorTAU, typename Workspace >
 inline integer_t hetrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAU& tau, Workspace work = optimal_workspace() ) {
+ VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hetrd_impl< value_type >::compute( a, d, e, tau, info, work );
     return info;
 }
 
+// template function to call hetrd, default workspace type
+template< typename MatrixA, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline integer_t hetrd( MatrixA& a, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hetrd_impl< value_type >::compute( a, d, e, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -52,6 +54,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -94,14 +98,23 @@
 
 // template function to call hetrf
 template< typename MatrixA, typename VectorIPIV, typename Workspace >
-inline integer_t hetrf( MatrixA& a, VectorIPIV& ipiv,
- Workspace work = optimal_workspace() ) {
+inline integer_t hetrf( MatrixA& a, VectorIPIV& ipiv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hetrf_impl< value_type >::compute( a, ipiv, info, work );
     return info;
 }
 
+// template function to call hetrf, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t hetrf( MatrixA& a, VectorIPIV& ipiv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hetrf_impl< value_type >::compute( a, ipiv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -52,6 +54,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -96,13 +100,23 @@
 // template function to call hetri
 template< typename MatrixA, typename VectorIPIV, typename Workspace >
 inline integer_t hetri( char const uplo, MatrixA& a, VectorIPIV& ipiv,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hetri_impl< value_type >::compute( uplo, a, ipiv, info, work );
     return info;
 }
 
+// template function to call hetri, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t hetri( char const uplo, MatrixA& a, VectorIPIV& ipiv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hetri_impl< value_type >::compute( uplo, a, ipiv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -52,6 +54,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HGEQZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -94,6 +96,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHAR,
@@ -190,6 +193,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHA,
@@ -294,13 +298,28 @@
 inline integer_t hgeqz( char const job, char const compq,
         char const compz, integer_t const ilo, MatrixH& h, MatrixT& t,
         VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
- MatrixQ& q, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ MatrixQ& q, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
     integer_t info(0);
     hgeqz_impl< value_type >::compute( job, compq, compz, ilo, h, t,
             alphar, alphai, beta, q, z, info, work );
     return info;
 }
+
+// template function to call hgeqz, default workspace type
+template< typename MatrixH, typename MatrixT, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixQ,
+ typename MatrixZ >
+inline integer_t hgeqz( char const job, char const compq,
+ char const compz, integer_t const ilo, MatrixH& h, MatrixT& t,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
+ integer_t info(0);
+ hgeqz_impl< value_type >::compute( job, compq, compz, ilo, h, t,
+ alphar, alphai, beta, q, z, info, optimal_workspace() );
+ return info;
+}
 // template function to call hgeqz
 template< typename MatrixH, typename MatrixT, typename VectorALPHA,
         typename VectorBETA, typename MatrixQ, typename MatrixZ,
@@ -308,7 +327,7 @@
 inline integer_t hgeqz( char const job, char const compq,
         char const compz, integer_t const ilo, MatrixH& h, MatrixT& t,
         VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
     integer_t info(0);
     hgeqz_impl< value_type >::compute( job, compq, compz, ilo, h, t,
@@ -316,6 +335,19 @@
     return info;
 }
 
+// template function to call hgeqz, default workspace type
+template< typename MatrixH, typename MatrixT, typename VectorALPHA,
+ typename VectorBETA, typename MatrixQ, typename MatrixZ >
+inline integer_t hgeqz( char const job, char const compq,
+ char const compz, integer_t const ilo, MatrixH& h, MatrixT& t,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
+ integer_t info(0);
+ hgeqz_impl< value_type >::compute( job, compq, compz, ilo, h, t,
+ alpha, beta, q, z, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -62,6 +64,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -147,7 +151,7 @@
         typename VectorBERR, typename Workspace >
 inline integer_t hprfs( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hprfs_impl< value_type >::compute( n, ap, afp, ipiv, b, x, ferr,
@@ -155,6 +159,20 @@
     return info;
 }
 
+// template function to call hprfs, default workspace type
+template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t hprfs( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hprfs_impl< value_type >::compute( n, ap, afp, ipiv, b, x, ferr,
+ berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -50,6 +52,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEIN_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -91,6 +93,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixH, typename VectorWR,
@@ -181,6 +184,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixH, typename VectorW,
@@ -277,7 +281,7 @@
         char const initv, VectorSELECT& select, MatrixH& h, VectorWR& wr,
         VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t const mm,
         integer_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -285,6 +289,22 @@
             wr, wi, vl, vr, mm, m, ifaill, ifailr, info, work );
     return info;
 }
+
+// template function to call hsein, default workspace type
+template< typename VectorSELECT, typename MatrixH, typename VectorWR,
+ typename VectorWI, typename MatrixVL, typename MatrixVR,
+ typename VectorIFAILL, typename VectorIFAILR >
+inline integer_t hsein( char const side, char const eigsrc,
+ char const initv, VectorSELECT& select, MatrixH& h, VectorWR& wr,
+ VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t const mm,
+ integer_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ hsein_impl< value_type >::compute( side, eigsrc, initv, select, h,
+ wr, wi, vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
+ return info;
+}
 // template function to call hsein
 template< typename VectorSELECT, typename MatrixH, typename VectorW,
         typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
@@ -292,8 +312,7 @@
 inline integer_t hsein( char const side, char const eigsrc,
         char const initv, VectorSELECT& select, MatrixH& h, VectorW& w,
         MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
- VectorIFAILL& ifaill, VectorIFAILR& ifailr,
- Workspace work = optimal_workspace() ) {
+ VectorIFAILL& ifaill, VectorIFAILR& ifailr, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -302,6 +321,22 @@
     return info;
 }
 
+// template function to call hsein, default workspace type
+template< typename VectorSELECT, typename MatrixH, typename VectorW,
+ typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
+ typename VectorIFAILR >
+inline integer_t hsein( char const side, char const eigsrc,
+ char const initv, VectorSELECT& select, MatrixH& h, VectorW& w,
+ MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
+ VectorIFAILL& ifaill, VectorIFAILR& ifailr ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ hsein_impl< value_type >::compute( side, eigsrc, initv, select, h, w,
+ vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -81,6 +83,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixH, typename VectorWR, typename VectorWI,
@@ -147,6 +150,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixH, typename VectorW, typename MatrixZ,
@@ -201,19 +205,32 @@
         typename MatrixZ, typename Workspace >
 inline integer_t hseqr( char const job, char const compz,
         integer_t const ilo, integer_t const ihi, MatrixH& h, VectorWR& wr,
- VectorWI& wi, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorWI& wi, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
     integer_t info(0);
     hseqr_impl< value_type >::compute( job, compz, ilo, ihi, h, wr, wi,
             z, info, work );
     return info;
 }
+
+// template function to call hseqr, default workspace type
+template< typename MatrixH, typename VectorWR, typename VectorWI,
+ typename MatrixZ >
+inline integer_t hseqr( char const job, char const compz,
+ integer_t const ilo, integer_t const ihi, MatrixH& h, VectorWR& wr,
+ VectorWI& wi, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
+ integer_t info(0);
+ hseqr_impl< value_type >::compute( job, compz, ilo, ihi, h, wr, wi,
+ z, info, optimal_workspace() );
+ return info;
+}
 // template function to call hseqr
 template< typename MatrixH, typename VectorW, typename MatrixZ,
         typename Workspace >
 inline integer_t hseqr( char const job, char const compz,
         integer_t const ilo, integer_t const ihi, MatrixH& h, VectorW& w,
- MatrixZ& z, Workspace work = optimal_workspace() ) {
+ MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
     integer_t info(0);
     hseqr_impl< value_type >::compute( job, compz, ilo, ihi, h, w, z,
@@ -221,6 +238,18 @@
     return info;
 }
 
+// template function to call hseqr, default workspace type
+template< typename MatrixH, typename VectorW, typename MatrixZ >
+inline integer_t hseqr( char const job, char const compz,
+ integer_t const ilo, integer_t const ihi, MatrixH& h, VectorW& w,
+ MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
+ integer_t info(0);
+ hseqr_impl< value_type >::compute( job, compz, ilo, ihi, h, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LABRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -77,6 +79,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
@@ -132,6 +135,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorD, typename VectorE,

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LACON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -65,6 +67,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorX, typename V, typename ISGN >
@@ -111,6 +114,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorX, typename V >
@@ -148,13 +152,25 @@
 template< typename VectorX, typename Workspace >
 inline integer_t lacon( integer_t const n, VectorX& x,
         typename traits::vector_traits< VectorX >::value_type& est,
- integer_t& kase, Workspace work = optimal_workspace() ) {
+ integer_t& kase, Workspace work ) {
     typedef typename traits::vector_traits< VectorX >::value_type value_type;
     integer_t info(0);
     lacon_impl< value_type >::compute( n, x, est, kase, work );
     return info;
 }
 
+// template function to call lacon, default workspace type
+template< typename VectorX >
+inline integer_t lacon( integer_t const n, VectorX& x,
+ typename traits::vector_traits< VectorX >::value_type& est,
+ integer_t& kase ) {
+ typedef typename traits::vector_traits< VectorX >::value_type value_type;
+ integer_t info(0);
+ lacon_impl< value_type >::compute( n, x, est, kase,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LAEBZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -60,6 +62,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorE2,
@@ -156,8 +159,7 @@
         typename traits::vector_traits< VectorD >::value_type const reltol,
         typename traits::vector_traits< VectorD >::value_type const pivmin,
         VectorD& d, VectorE& e, VectorE2& e2, VectorNVAL& nval, MatrixAB& ab,
- VectorC& c, integer_t& mout, MatrixNAB& nab,
- Workspace work = optimal_workspace() ) {
+ VectorC& c, integer_t& mout, MatrixNAB& nab, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     laebz_impl< value_type >::compute( ijob, nitmax, n, minp, nbmin,
@@ -166,6 +168,25 @@
     return info;
 }
 
+// template function to call laebz, default workspace type
+template< typename VectorD, typename VectorE, typename VectorE2,
+ typename VectorNVAL, typename MatrixAB, typename VectorC,
+ typename MatrixNAB >
+inline integer_t laebz( integer_t const ijob, integer_t const nitmax,
+ integer_t const n, integer_t const minp, integer_t const nbmin,
+ typename traits::vector_traits< VectorD >::value_type const abstol,
+ typename traits::vector_traits< VectorD >::value_type const reltol,
+ typename traits::vector_traits< VectorD >::value_type const pivmin,
+ VectorD& d, VectorE& e, VectorE2& e2, VectorNVAL& nval, MatrixAB& ab,
+ VectorC& c, integer_t& mout, MatrixNAB& nab ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ laebz_impl< value_type >::compute( ijob, nitmax, n, minp, nbmin,
+ abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LARZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorV, typename MatrixC, typename WORK >
@@ -128,6 +131,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorV, typename MatrixC, typename WORK >
@@ -182,14 +186,25 @@
 template< typename VectorV, typename MatrixC, typename Workspace >
 inline integer_t larz( char const side, integer_t const l, VectorV& v,
         integer_t const incv, typename traits::vector_traits<
- VectorV >::value_type const tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ VectorV >::value_type const tau, MatrixC& c, Workspace work ) {
     typedef typename traits::vector_traits< VectorV >::value_type value_type;
     integer_t info(0);
     larz_impl< value_type >::compute( side, l, v, incv, tau, c, work );
     return info;
 }
 
+// template function to call larz, default workspace type
+template< typename VectorV, typename MatrixC >
+inline integer_t larz( char const side, integer_t const l, VectorV& v,
+ integer_t const incv, typename traits::vector_traits<
+ VectorV >::value_type const tau, MatrixC& c ) {
+ typedef typename traits::vector_traits< VectorV >::value_type value_type;
+ integer_t info(0);
+ larz_impl< value_type >::compute( side, l, v, incv, tau, c,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -69,6 +71,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorE, typename VectorTAU,
@@ -103,6 +106,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorE, typename VectorTAU,

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -75,6 +77,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorX, typename VectorCNORM >
@@ -108,6 +111,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorX, typename VectorCNORM >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -69,6 +71,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -117,6 +120,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -162,14 +166,22 @@
 
 // template function to call latrz
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t latrz( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t latrz( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     latrz_impl< value_type >::compute( a, tau, work );
     return info;
 }
 
+// template function to call latrz, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t latrz( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ latrz_impl< value_type >::compute( a, tau, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPGTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -50,6 +52,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ,
@@ -105,13 +108,24 @@
 template< typename VectorAP, typename VectorTAU, typename MatrixQ,
         typename Workspace >
 inline integer_t opgtr( char const uplo, VectorAP& ap, VectorTAU& tau,
- MatrixQ& q, Workspace work = optimal_workspace() ) {
+ MatrixQ& q, Workspace work ) {
     typedef typename traits::vector_traits< VectorAP >::value_type value_type;
     integer_t info(0);
     opgtr_impl< value_type >::compute( uplo, ap, tau, q, info, work );
     return info;
 }
 
+// template function to call opgtr, default workspace type
+template< typename VectorAP, typename VectorTAU, typename MatrixQ >
+inline integer_t opgtr( char const uplo, VectorAP& ap, VectorTAU& tau,
+ MatrixQ& q ) {
+ typedef typename traits::vector_traits< VectorAP >::value_type value_type;
+ integer_t info(0);
+ opgtr_impl< value_type >::compute( uplo, ap, tau, q, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPMTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -52,6 +54,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC,
@@ -115,7 +118,7 @@
         typename Workspace >
 inline integer_t opmtr( char const side, char const uplo,
         char const trans, VectorAP& ap, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorAP >::value_type value_type;
     integer_t info(0);
     opmtr_impl< value_type >::compute( side, uplo, trans, ap, tau, c,
@@ -123,6 +126,17 @@
     return info;
 }
 
+// template function to call opmtr, default workspace type
+template< typename VectorAP, typename VectorTAU, typename MatrixC >
+inline integer_t opmtr( char const side, char const uplo,
+ char const trans, VectorAP& ap, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::vector_traits< VectorAP >::value_type value_type;
+ integer_t info(0);
+ opmtr_impl< value_type >::compute( side, uplo, trans, ap, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGBR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -105,7 +108,7 @@
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orgbr( char const vect, integer_t const m,
         integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orgbr_impl< value_type >::compute( vect, m, n, k, a, tau, info,
@@ -113,6 +116,17 @@
     return info;
 }
 
+// template function to call orgbr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orgbr( char const vect, integer_t const m,
+ integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orgbr_impl< value_type >::compute( vect, m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGHR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -104,14 +107,24 @@
 // template function to call orghr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orghr( integer_t const n, integer_t const ilo,
- integer_t const ihi, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const ihi, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orghr_impl< value_type >::compute( n, ilo, ihi, a, tau, info, work );
     return info;
 }
 
+// template function to call orghr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orghr( integer_t const n, integer_t const ilo,
+ integer_t const ihi, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orghr_impl< value_type >::compute( n, ilo, ihi, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGLQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -105,14 +108,24 @@
 // template function to call orglq
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orglq( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orglq_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call orglq, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orglq( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orglq_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -105,14 +108,24 @@
 // template function to call orgql
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orgql( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orgql_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call orgql, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orgql( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orgql_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -105,14 +108,24 @@
 // template function to call orgqr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orgqr( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orgqr_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call orgqr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orgqr( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orgqr_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGRQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -105,14 +108,24 @@
 // template function to call orgrq
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orgrq( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orgrq_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call orgrq, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orgrq( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orgrq_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -103,13 +106,23 @@
 // template function to call orgtr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t orgtr( integer_t const n, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     orgtr_impl< value_type >::compute( n, a, tau, info, work );
     return info;
 }
 
+// template function to call orgtr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t orgtr( integer_t const n, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ orgtr_impl< value_type >::compute( n, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMBR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -132,7 +135,7 @@
         typename Workspace >
 inline integer_t ormbr( char const vect, char const side,
         char const trans, integer_t const k, MatrixA& a, VectorTAU& tau,
- MatrixC& c, Workspace work = optimal_workspace() ) {
+ MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormbr_impl< value_type >::compute( vect, side, trans, k, a, tau, c,
@@ -140,6 +143,18 @@
     return info;
 }
 
+// template function to call ormbr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormbr( char const vect, char const side,
+ char const trans, integer_t const k, MatrixA& a, VectorTAU& tau,
+ MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormbr_impl< value_type >::compute( vect, side, trans, k, a, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMHR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -134,7 +137,7 @@
         typename Workspace >
 inline integer_t ormhr( char const side, char const trans,
         integer_t const ilo, integer_t const ihi, MatrixA& a, VectorTAU& tau,
- MatrixC& c, Workspace work = optimal_workspace() ) {
+ MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormhr_impl< value_type >::compute( side, trans, ilo, ihi, a, tau, c,
@@ -142,6 +145,18 @@
     return info;
 }
 
+// template function to call ormhr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormhr( char const side, char const trans,
+ integer_t const ilo, integer_t const ihi, MatrixA& a, VectorTAU& tau,
+ MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormhr_impl< value_type >::compute( side, trans, ilo, ihi, a, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMLQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -128,7 +131,7 @@
         typename Workspace >
 inline integer_t ormlq( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormlq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -136,6 +139,17 @@
     return info;
 }
 
+// template function to call ormlq, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormlq( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormlq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -127,7 +130,7 @@
         typename Workspace >
 inline integer_t ormql( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormql_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -135,6 +138,17 @@
     return info;
 }
 
+// template function to call ormql, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormql( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormql_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -127,7 +130,7 @@
         typename Workspace >
 inline integer_t ormqr( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormqr_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -135,6 +138,17 @@
     return info;
 }
 
+// template function to call ormqr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormqr( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormqr_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -128,7 +131,7 @@
         typename Workspace >
 inline integer_t ormrq( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormrq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -136,6 +139,17 @@
     return info;
 }
 
+// template function to call ormrq, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormrq( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormrq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -126,7 +129,7 @@
         typename Workspace >
 inline integer_t ormrz( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormrz_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -134,6 +137,17 @@
     return info;
 }
 
+// template function to call ormrz, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormrz( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormrz_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -128,7 +131,7 @@
 template< typename MatrixA, typename VectorTAU, typename MatrixC,
         typename Workspace >
 inline integer_t ormtr( char const side, char const trans, MatrixA& a,
- VectorTAU& tau, MatrixC& c, Workspace work = optimal_workspace() ) {
+ VectorTAU& tau, MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ormtr_impl< value_type >::compute( side, trans, a, tau, c, info,
@@ -136,6 +139,17 @@
     return info;
 }
 
+// template function to call ormtr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t ormtr( char const side, char const trans, MatrixA& a,
+ VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ormtr_impl< value_type >::compute( side, trans, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename IWORK >
@@ -128,6 +131,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename RWORK >
@@ -183,7 +187,7 @@
 inline integer_t pbcon( char const uplo, integer_t const n,
         integer_t const kd, MatrixAB& ab, typename traits::matrix_traits<
         MatrixAB >::value_type const anorm, typename traits::matrix_traits<
- MatrixAB >::value_type& rcond, Workspace work = optimal_workspace() ) {
+ MatrixAB >::value_type& rcond, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     pbcon_impl< value_type >::compute( uplo, n, kd, ab, anorm, rcond,
@@ -191,6 +195,19 @@
     return info;
 }
 
+// template function to call pbcon, default workspace type
+template< typename MatrixAB >
+inline integer_t pbcon( char const uplo, integer_t const n,
+ integer_t const kd, MatrixAB& ab, typename traits::matrix_traits<
+ MatrixAB >::value_type const anorm, typename traits::matrix_traits<
+ MatrixAB >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ pbcon_impl< value_type >::compute( uplo, n, kd, ab, anorm, rcond,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBEQU_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -67,6 +69,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorS >
@@ -92,6 +95,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorS >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
@@ -171,6 +175,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
@@ -255,8 +261,7 @@
         typename Workspace >
 inline integer_t pbrfs( integer_t const n, integer_t const kd,
         MatrixAB& ab, MatrixAFB& afb, MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     pbrfs_impl< value_type >::compute( n, kd, ab, afb, b, x, ferr, berr,
@@ -264,6 +269,19 @@
     return info;
 }
 
+// template function to call pbrfs, default workspace type
+template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t pbrfs( integer_t const n, integer_t const kd,
+ MatrixAB& ab, MatrixAFB& afb, MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ pbrfs_impl< value_type >::compute( n, kd, ab, afb, b, x, ferr, berr,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBSTF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
@@ -127,6 +130,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
@@ -180,13 +184,25 @@
 template< typename MatrixA, typename Workspace >
 inline integer_t pocon( MatrixA& a, typename traits::matrix_traits<
         MatrixA >::value_type const anorm, typename traits::matrix_traits<
- MatrixA >::value_type& rcond, Workspace work = optimal_workspace() ) {
+ MatrixA >::value_type& rcond, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     pocon_impl< value_type >::compute( a, anorm, rcond, info, work );
     return info;
 }
 
+// template function to call pocon, default workspace type
+template< typename MatrixA >
+inline integer_t pocon( MatrixA& a, typename traits::matrix_traits<
+ MatrixA >::value_type const anorm, typename traits::matrix_traits<
+ MatrixA >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ pocon_impl< value_type >::compute( a, anorm, rcond, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POEQU_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -65,6 +67,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorS >
@@ -88,6 +91,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorS >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PORFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
@@ -175,6 +179,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
@@ -262,8 +268,7 @@
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
 inline integer_t porfs( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     porfs_impl< value_type >::compute( a, af, b, x, ferr, berr, info,
@@ -271,6 +276,18 @@
     return info;
 }
 
+// template function to call porfs, default workspace type
+template< typename MatrixA, typename MatrixAF, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t porfs( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ porfs_impl< value_type >::compute( a, af, b, x, ferr, berr, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -83,6 +85,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
@@ -165,6 +169,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
@@ -245,7 +251,7 @@
         typename Workspace >
 inline integer_t pprfs( integer_t const n, MatrixAP& ap, VectorAFP& afp,
         MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     pprfs_impl< value_type >::compute( n, ap, afp, b, x, ferr, berr,
@@ -253,6 +259,18 @@
     return info;
 }
 
+// template function to call pprfs, default workspace type
+template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t pprfs( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ pprfs_impl< value_type >::compute( n, ap, afp, b, x, ferr, berr,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorAP, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTEQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -69,6 +71,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -120,6 +123,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -167,13 +171,24 @@
 template< typename VectorD, typename VectorE, typename MatrixZ,
         typename Workspace >
 inline integer_t pteqr( char const compz, integer_t const n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixZ& z, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     pteqr_impl< value_type >::compute( compz, n, d, e, z, info, work );
     return info;
 }
 
+// template function to call pteqr, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixZ >
+inline integer_t pteqr( char const compz, integer_t const n, VectorD& d,
+ VectorE& e, MatrixZ& z ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ pteqr_impl< value_type >::compute( compz, n, d, e, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -83,6 +85,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
@@ -170,6 +173,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
@@ -265,21 +269,34 @@
         typename VectorFERR, typename VectorBERR, typename Workspace >
 inline integer_t ptrfs( integer_t const n, VectorD& d, VectorE& e,
         VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     ptrfs_impl< value_type >::compute( n, d, e, df, ef, b, x, ferr, berr,
             info, work );
     return info;
 }
+
+// template function to call ptrfs, default workspace type
+template< typename VectorD, typename VectorE, typename VectorDF,
+ typename VectorEF, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t ptrfs( integer_t const n, VectorD& d, VectorE& e,
+ VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ ptrfs_impl< value_type >::compute( n, d, e, df, ef, b, x, ferr, berr,
+ info, optimal_workspace() );
+ return info;
+}
 // template function to call ptrfs
 template< typename VectorD, typename VectorE, typename VectorDF,
         typename VectorEF, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR, typename Workspace >
 inline integer_t ptrfs( char const uplo, integer_t const n, VectorD& d,
         VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     ptrfs_impl< value_type >::compute( uplo, n, d, e, df, ef, b, x, ferr,
@@ -287,6 +304,20 @@
     return info;
 }
 
+// template function to call ptrfs, default workspace type
+template< typename VectorD, typename VectorE, typename VectorDF,
+ typename VectorEF, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t ptrfs( char const uplo, integer_t const n, VectorD& d,
+ VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ ptrfs_impl< value_type >::compute( uplo, n, d, e, df, ef, b, x, ferr,
+ berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -65,6 +67,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >
@@ -94,6 +97,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBGST_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
@@ -115,7 +118,7 @@
         typename Workspace >
 inline integer_t sbgst( char const vect, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- MatrixX& x, Workspace work = optimal_workspace() ) {
+ MatrixX& x, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbgst_impl< value_type >::compute( vect, n, ka, kb, ab, bb, x, info,
@@ -123,6 +126,18 @@
     return info;
 }
 
+// template function to call sbgst, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename MatrixX >
+inline integer_t sbgst( char const vect, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ MatrixX& x ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbgst_impl< value_type >::compute( vect, n, ka, kb, ab, bb, x, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBTRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
@@ -116,7 +119,7 @@
         typename MatrixQ, typename Workspace >
 inline integer_t sbtrd( char const vect, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbtrd_impl< value_type >::compute( vect, n, kd, ab, d, e, q, info,
@@ -124,6 +127,19 @@
     return info;
 }
 
+// template function to call sbtrd, default workspace type
+template< typename MatrixAB, typename VectorD, typename VectorE,
+ typename MatrixQ >
+inline integer_t sbtrd( char const vect, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
+ MatrixQ& q ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbtrd_impl< value_type >::compute( vect, n, kd, ab, d, e, q, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -172,6 +176,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -257,7 +263,7 @@
         typename VectorBERR, typename Workspace >
 inline integer_t sprfs( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     sprfs_impl< value_type >::compute( n, ap, afp, ipiv, b, x, ferr,
@@ -265,6 +271,20 @@
     return info;
 }
 
+// template function to call sprfs, default workspace type
+template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t sprfs( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ sprfs_impl< value_type >::compute( n, ap, afp, ipiv, b, x, ferr,
+ berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEBZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -58,6 +60,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -146,7 +149,7 @@
         integer_t const iu, typename traits::vector_traits<
         VectorD >::value_type const abstol, VectorD& d, VectorE& e,
         integer_t& m, integer_t& nsplit, VectorW& w, VectorIBLOCK& iblock,
- VectorISPLIT& isplit, Workspace work = optimal_workspace() ) {
+ VectorISPLIT& isplit, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stebz_impl< value_type >::compute( range, order, n, vl, vu, il, iu,
@@ -154,6 +157,25 @@
     return info;
 }
 
+// template function to call stebz, default workspace type
+template< typename VectorD, typename VectorE, typename VectorW,
+ typename VectorIBLOCK, typename VectorISPLIT >
+inline integer_t stebz( char const range, char const order,
+ integer_t const n, typename traits::vector_traits<
+ VectorD >::value_type const vl, typename traits::vector_traits<
+ VectorD >::value_type const vu, integer_t const il,
+ integer_t const iu, typename traits::vector_traits<
+ VectorD >::value_type const abstol, VectorD& d, VectorE& e,
+ integer_t& m, integer_t& nsplit, VectorW& w, VectorIBLOCK& iblock,
+ VectorISPLIT& isplit ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stebz_impl< value_type >::compute( range, order, n, vl, vu, il, iu,
+ abstol, d, e, m, nsplit, w, iblock, isplit, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEDC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -80,6 +82,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -151,6 +154,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -233,13 +237,24 @@
 template< typename VectorD, typename VectorE, typename MatrixZ,
         typename Workspace >
 inline integer_t stedc( char const compz, integer_t const n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixZ& z, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stedc_impl< value_type >::compute( compz, n, d, e, z, info, work );
     return info;
 }
 
+// template function to call stedc, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixZ >
+inline integer_t stedc( char const compz, integer_t const n, VectorD& d,
+ VectorE& e, MatrixZ& z ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stedc_impl< value_type >::compute( compz, n, d, e, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEGR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -87,6 +89,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -179,6 +182,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -273,7 +277,7 @@
         integer_t const il, integer_t const iu,
         typename traits::vector_traits< VectorD >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stegr_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
@@ -281,6 +285,23 @@
     return info;
 }
 
+// template function to call stegr, default workspace type
+template< typename VectorD, typename VectorE, typename VectorW,
+ typename MatrixZ, typename VectorISUPPZ >
+inline integer_t stegr( char const jobz, char const range,
+ integer_t const n, VectorD& d, VectorE& e,
+ typename traits::vector_traits< VectorD >::value_type const vl,
+ typename traits::vector_traits< VectorD >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::vector_traits< VectorD >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stegr_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
+ iu, abstol, m, w, z, isuppz, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEIN_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -76,6 +78,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -161,6 +164,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -245,7 +249,7 @@
 inline integer_t stein( integer_t const n, VectorD& d, VectorE& e,
         integer_t const m, VectorW& w, VectorIBLOCK& iblock,
         VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stein_impl< value_type >::compute( n, d, e, m, w, iblock, isplit, z,
@@ -253,6 +257,20 @@
     return info;
 }
 
+// template function to call stein, default workspace type
+template< typename VectorD, typename VectorE, typename VectorW,
+ typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
+ typename VectorIFAIL >
+inline integer_t stein( integer_t const n, VectorD& d, VectorE& e,
+ integer_t const m, VectorW& w, VectorIBLOCK& iblock,
+ VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stein_impl< value_type >::compute( n, d, e, m, w, iblock, isplit, z,
+ ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -69,6 +71,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -120,6 +123,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -167,13 +171,24 @@
 template< typename VectorD, typename VectorE, typename MatrixZ,
         typename Workspace >
 inline integer_t steqr( char const compz, integer_t const n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixZ& z, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     steqr_impl< value_type >::compute( compz, n, d, e, z, info, work );
     return info;
 }
 
+// template function to call steqr, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixZ >
+inline integer_t steqr( char const compz, integer_t const n, VectorD& d,
+ VectorE& e, MatrixZ& z ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ steqr_impl< value_type >::compute( compz, n, d, e, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STERF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -46,6 +48,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorD, typename VectorE >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK,
@@ -133,6 +137,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -182,7 +188,7 @@
 inline integer_t sycon( char const uplo, MatrixA& a, VectorIPIV& ipiv,
         typename traits::matrix_traits< MatrixA >::value_type const anorm,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sycon_impl< value_type >::compute( uplo, a, ipiv, anorm, rcond, info,
@@ -190,6 +196,18 @@
     return info;
 }
 
+// template function to call sycon, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t sycon( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ typename traits::matrix_traits< MatrixA >::value_type const anorm,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sycon_impl< value_type >::compute( uplo, a, ipiv, anorm, rcond, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYGST_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -48,6 +50,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -180,6 +184,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -273,7 +279,7 @@
         typename VectorBERR, typename Workspace >
 inline integer_t syrfs( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
         MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     syrfs_impl< value_type >::compute( a, af, ipiv, b, x, ferr, berr,
@@ -281,6 +287,19 @@
     return info;
 }
 
+// template function to call syrfs, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t syrfs( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ syrfs_impl< value_type >::compute( a, af, ipiv, b, x, ferr, berr,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
@@ -121,13 +124,25 @@
 template< typename MatrixA, typename VectorD, typename VectorE,
         typename VectorTAU, typename Workspace >
 inline integer_t sytrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAU& tau, Workspace work = optimal_workspace() ) {
+ VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sytrd_impl< value_type >::compute( a, d, e, tau, info, work );
     return info;
 }
 
+// template function to call sytrd, default workspace type
+template< typename MatrixA, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline integer_t sytrd( MatrixA& a, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sytrd_impl< value_type >::compute( a, d, e, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -70,6 +72,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -123,6 +127,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -173,14 +179,23 @@
 
 // template function to call sytrf
 template< typename MatrixA, typename VectorIPIV, typename Workspace >
-inline integer_t sytrf( MatrixA& a, VectorIPIV& ipiv,
- Workspace work = optimal_workspace() ) {
+inline integer_t sytrf( MatrixA& a, VectorIPIV& ipiv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sytrf_impl< value_type >::compute( a, ipiv, info, work );
     return info;
 }
 
+// template function to call sytrf, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t sytrf( MatrixA& a, VectorIPIV& ipiv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sytrf_impl< value_type >::compute( a, ipiv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -69,6 +71,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -115,6 +119,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::pivot > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
@@ -159,13 +165,23 @@
 // template function to call sytri
 template< typename MatrixA, typename VectorIPIV, typename Workspace >
 inline integer_t sytri( char const uplo, MatrixA& a, VectorIPIV& ipiv,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sytri_impl< value_type >::compute( uplo, a, ipiv, info, work );
     return info;
 }
 
+// template function to call sytri, default workspace type
+template< typename MatrixA, typename VectorIPIV >
+inline integer_t sytri( char const uplo, MatrixA& a, VectorIPIV& ipiv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sytri_impl< value_type >::compute( uplo, a, ipiv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -63,6 +65,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -75,6 +77,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename IWORK >
@@ -133,6 +136,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename RWORK >
@@ -191,7 +195,7 @@
 inline integer_t tbcon( char const norm, char const uplo,
         char const diag, integer_t const n, integer_t const kd, MatrixAB& ab,
         typename traits::matrix_traits< MatrixAB >::value_type& rcond,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     tbcon_impl< value_type >::compute( norm, uplo, diag, n, kd, ab,
@@ -199,6 +203,18 @@
     return info;
 }
 
+// template function to call tbcon, default workspace type
+template< typename MatrixAB >
+inline integer_t tbcon( char const norm, char const uplo,
+ char const diag, integer_t const n, integer_t const kd, MatrixAB& ab,
+ typename traits::matrix_traits< MatrixAB >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ tbcon_impl< value_type >::compute( norm, uplo, diag, n, kd, ab,
+ rcond, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
@@ -170,6 +174,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
@@ -253,7 +259,7 @@
 inline integer_t tbrfs( char const uplo, char const trans,
         char const diag, integer_t const n, integer_t const kd, MatrixAB& ab,
         MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     tbrfs_impl< value_type >::compute( uplo, trans, diag, n, kd, ab, b,
@@ -261,6 +267,19 @@
     return info;
 }
 
+// template function to call tbrfs, default workspace type
+template< typename MatrixAB, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t tbrfs( char const uplo, char const trans,
+ char const diag, integer_t const n, integer_t const kd, MatrixAB& ab,
+ MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ tbrfs_impl< value_type >::compute( uplo, trans, diag, n, kd, ab, b,
+ x, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -68,6 +70,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEVC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
@@ -152,6 +155,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
@@ -229,7 +233,7 @@
 inline integer_t tgevc( char const side, char const howmny,
         VectorSELECT& select, integer_t const n, MatrixS& s, MatrixP& p,
         MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -238,6 +242,20 @@
     return info;
 }
 
+// template function to call tgevc, default workspace type
+template< typename VectorSELECT, typename MatrixS, typename MatrixP,
+ typename MatrixVL, typename MatrixVR >
+inline integer_t tgevc( char const side, char const howmny,
+ VectorSELECT& select, integer_t const n, MatrixS& s, MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ tgevc_impl< value_type >::compute( side, howmny, select, n, s, p, vl,
+ vr, mm, m, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEXC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
@@ -119,6 +123,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
@@ -189,8 +195,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t tgexc( logical_t const wantq, logical_t const wantz,
         integer_t const n, MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
- integer_t const ifst, integer_t& ilst,
- Workspace work = optimal_workspace() ) {
+ integer_t const ifst, integer_t& ilst, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     tgexc_impl< value_type >::compute( wantq, wantz, n, a, b, q, z, ifst,
@@ -198,6 +203,19 @@
     return info;
 }
 
+// template function to call tgexc, default workspace type
+template< typename MatrixA, typename MatrixB, typename MatrixQ,
+ typename MatrixZ >
+inline integer_t tgexc( logical_t const wantq, logical_t const wantz,
+ integer_t const n, MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ integer_t const ifst, integer_t& ilst ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ tgexc_impl< value_type >::compute( wantq, wantz, n, a, b, q, z, ifst,
+ ilst, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSEN_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -104,6 +106,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
@@ -222,6 +226,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
@@ -338,7 +344,7 @@
         VectorBETA& beta, MatrixQ& q, MatrixZ& z, integer_t& m,
         typename traits::vector_traits< VectorSELECT >::value_type& pl,
         typename traits::vector_traits< VectorSELECT >::value_type& pr,
- VectorDIF& dif, Workspace work = optimal_workspace() ) {
+ VectorDIF& dif, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -346,6 +352,26 @@
             b, alphar, alphai, beta, q, z, m, pl, pr, dif, info, work );
     return info;
 }
+
+// template function to call tgsen, default workspace type
+template< typename VectorSELECT, typename MatrixA, typename MatrixB,
+ typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA,
+ typename MatrixQ, typename MatrixZ, typename VectorDIF >
+inline integer_t tgsen( integer_t const ijob, logical_t const wantq,
+ logical_t const wantz, VectorSELECT& select, integer_t const n,
+ MatrixA& a, MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, integer_t& m,
+ typename traits::vector_traits< VectorSELECT >::value_type& pl,
+ typename traits::vector_traits< VectorSELECT >::value_type& pr,
+ VectorDIF& dif ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ tgsen_impl< value_type >::compute( ijob, wantq, wantz, select, n, a,
+ b, alphar, alphai, beta, q, z, m, pl, pr, dif, info,
+ optimal_workspace() );
+ return info;
+}
 // template function to call tgsen
 template< typename VectorSELECT, typename MatrixA, typename MatrixB,
         typename VectorALPHA, typename VectorBETA, typename MatrixQ,
@@ -355,8 +381,7 @@
         MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
         MatrixQ& q, MatrixZ& z, integer_t& m, typename traits::vector_traits<
         VectorSELECT >::value_type& pl, typename traits::vector_traits<
- VectorSELECT >::value_type& pr, VectorDIF& dif,
- Workspace work = optimal_workspace() ) {
+ VectorSELECT >::value_type& pr, VectorDIF& dif, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -365,6 +390,24 @@
     return info;
 }
 
+// template function to call tgsen, default workspace type
+template< typename VectorSELECT, typename MatrixA, typename MatrixB,
+ typename VectorALPHA, typename VectorBETA, typename MatrixQ,
+ typename MatrixZ, typename VectorDIF >
+inline integer_t tgsen( integer_t const ijob, logical_t const wantq,
+ logical_t const wantz, VectorSELECT& select, integer_t const n,
+ MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, integer_t& m, typename traits::vector_traits<
+ VectorSELECT >::value_type& pl, typename traits::vector_traits<
+ VectorSELECT >::value_type& pr, VectorDIF& dif ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ tgsen_impl< value_type >::compute( ijob, wantq, wantz, select, n, a,
+ b, alpha, beta, q, z, m, pl, pr, dif, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSJA_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -99,6 +101,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -194,6 +198,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -291,7 +297,7 @@
         MatrixA >::value_type const tola, typename traits::matrix_traits<
         MatrixA >::value_type const tolb, VectorALPHA& alpha,
         VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
- integer_t& ncycle, Workspace work = optimal_workspace() ) {
+ integer_t& ncycle, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     tgsja_impl< value_type >::compute( jobu, jobv, jobq, k, l, a, b,
@@ -299,6 +305,25 @@
     return info;
 }
 
+// template function to call tgsja, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixU, typename MatrixV,
+ typename MatrixQ >
+inline integer_t tgsja( char const jobu, char const jobv,
+ char const jobq, integer_t const k, integer_t const l, MatrixA& a,
+ MatrixB& b, typename traits::matrix_traits<
+ MatrixA >::value_type const tola, typename traits::matrix_traits<
+ MatrixA >::value_type const tolb, VectorALPHA& alpha,
+ VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
+ integer_t& ncycle ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ tgsja_impl< value_type >::compute( jobu, jobv, jobq, k, l, a, b,
+ tola, tolb, alpha, beta, u, v, q, ncycle, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSNA_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -90,6 +92,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
@@ -193,6 +197,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
@@ -283,8 +289,7 @@
 inline integer_t tgsna( char const job, char const howmny,
         VectorSELECT& select, integer_t const n, MatrixA& a, MatrixB& b,
         MatrixVL& vl, MatrixVR& vr, VectorS& s, VectorDIF& dif,
- integer_t const mm, integer_t& m,
- Workspace work = optimal_workspace() ) {
+ integer_t const mm, integer_t& m, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -293,6 +298,22 @@
     return info;
 }
 
+// template function to call tgsna, default workspace type
+template< typename VectorSELECT, typename MatrixA, typename MatrixB,
+ typename MatrixVL, typename MatrixVR, typename VectorS,
+ typename VectorDIF >
+inline integer_t tgsna( char const job, char const howmny,
+ VectorSELECT& select, integer_t const n, MatrixA& a, MatrixB& b,
+ MatrixVL& vl, MatrixVR& vr, VectorS& s, VectorDIF& dif,
+ integer_t const mm, integer_t& m ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ tgsna_impl< value_type >::compute( job, howmny, select, n, a, b, vl,
+ vr, s, dif, mm, m, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSYL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -98,6 +100,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
@@ -192,6 +196,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
@@ -290,7 +296,7 @@
         MatrixC& c, MatrixD& d, MatrixE& e, MatrixF& f,
         typename traits::matrix_traits< MatrixA >::value_type& scale,
         typename traits::matrix_traits< MatrixA >::value_type& dif,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     tgsyl_impl< value_type >::compute( trans, ijob, m, n, a, b, c, d, e,
@@ -298,6 +304,21 @@
     return info;
 }
 
+// template function to call tgsyl, default workspace type
+template< typename MatrixA, typename MatrixB, typename MatrixC,
+ typename MatrixD, typename MatrixE, typename MatrixF >
+inline integer_t tgsyl( char const trans, integer_t const ijob,
+ integer_t const m, integer_t const n, MatrixA& a, MatrixB& b,
+ MatrixC& c, MatrixD& d, MatrixE& e, MatrixF& f,
+ typename traits::matrix_traits< MatrixA >::value_type& scale,
+ typename traits::matrix_traits< MatrixA >::value_type& dif ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ tgsyl_impl< value_type >::compute( trans, ijob, m, n, a, b, c, d, e,
+ f, scale, dif, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -81,6 +83,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
@@ -163,6 +167,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
@@ -242,8 +248,7 @@
         typename VectorFERR, typename VectorBERR, typename Workspace >
 inline integer_t tprfs( char const uplo, char const trans,
         char const diag, integer_t const n, MatrixAP& ap, MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     tprfs_impl< value_type >::compute( uplo, trans, diag, n, ap, b, x,
@@ -251,6 +256,19 @@
     return info;
 }
 
+// template function to call tprfs, default workspace type
+template< typename MatrixAP, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t tprfs( char const uplo, char const trans,
+ char const diag, integer_t const n, MatrixAP& ap, MatrixB& b,
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ tprfs_impl< value_type >::compute( uplo, trans, diag, n, ap, b, x,
+ ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRCON_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
@@ -131,6 +134,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
@@ -188,7 +192,7 @@
 template< typename MatrixA, typename Workspace >
 inline integer_t trcon( char const norm, char const uplo,
         char const diag, MatrixA& a, typename traits::matrix_traits<
- MatrixA >::value_type& rcond, Workspace work = optimal_workspace() ) {
+ MatrixA >::value_type& rcond, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     trcon_impl< value_type >::compute( norm, uplo, diag, a, rcond, info,
@@ -196,6 +200,18 @@
     return info;
 }
 
+// template function to call trcon, default workspace type
+template< typename MatrixA >
+inline integer_t trcon( char const norm, char const uplo,
+ char const diag, MatrixA& a, typename traits::matrix_traits<
+ MatrixA >::value_type& rcond ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ trcon_impl< value_type >::compute( norm, uplo, diag, a, rcond, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREVC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -81,6 +83,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
@@ -146,6 +149,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
@@ -220,8 +224,7 @@
         typename MatrixVR, typename Workspace >
 inline integer_t trevc( char const side, char const howmny,
         VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
- integer_t const mm, integer_t& m,
- Workspace work = optimal_workspace() ) {
+ integer_t const mm, integer_t& m, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -230,6 +233,20 @@
     return info;
 }
 
+// template function to call trevc, default workspace type
+template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
+ typename MatrixVR >
+inline integer_t trevc( char const side, char const howmny,
+ VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
+ integer_t const mm, integer_t& m ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ trevc_impl< value_type >::compute( side, howmny, select, t, vl, vr,
+ mm, m, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREXC_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -73,6 +75,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename MatrixT, typename MatrixQ >
@@ -102,6 +105,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixT, typename MatrixQ, $WORKSPACE_TYPENAMES >
@@ -156,8 +160,7 @@
 // template function to call trexc
 template< typename MatrixT, typename MatrixQ, typename Workspace >
 inline integer_t trexc( char const compq, MatrixT& t, MatrixQ& q,
- integer_t const ifst, integer_t const ilst,
- Workspace work = optimal_workspace() ) {
+ integer_t const ifst, integer_t const ilst, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixT >::value_type value_type;
     integer_t info(0);
     trexc_impl< value_type >::compute( compq, t, q, ifst, ilst, info,
@@ -165,6 +168,17 @@
     return info;
 }
 
+// template function to call trexc, default workspace type
+template< typename MatrixT, typename MatrixQ >
+inline integer_t trexc( char const compq, MatrixT& t, MatrixQ& q,
+ integer_t const ifst, integer_t const ilst ) {
+ typedef typename traits::matrix_traits< MatrixT >::value_type value_type;
+ integer_t info(0);
+ trexc_impl< value_type >::compute( compq, t, q, ifst, ilst, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRRFS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
@@ -172,6 +176,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
@@ -256,7 +262,7 @@
         typename VectorFERR, typename VectorBERR, typename Workspace >
 inline integer_t trrfs( char const uplo, char const trans,
         char const diag, MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work = optimal_workspace() ) {
+ VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     trrfs_impl< value_type >::compute( uplo, trans, diag, a, b, x, ferr,
@@ -264,6 +270,19 @@
     return info;
 }
 
+// template function to call trrfs, default workspace type
+template< typename MatrixA, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t trrfs( char const uplo, char const trans,
+ char const diag, MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ trrfs_impl< value_type >::compute( uplo, trans, diag, a, b, x, ferr,
+ berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSEN_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixQ,
@@ -137,8 +140,7 @@
         VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
         integer_t& m, typename traits::vector_traits<
         VectorSELECT >::value_type& s, typename traits::vector_traits<
- VectorSELECT >::value_type& sep,
- Workspace work = optimal_workspace() ) {
+ VectorSELECT >::value_type& sep, Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -147,6 +149,22 @@
     return info;
 }
 
+// template function to call trsen, default workspace type
+template< typename VectorSELECT, typename MatrixT, typename MatrixQ,
+ typename VectorW >
+inline integer_t trsen( char const job, char const compq,
+ VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
+ integer_t& m, typename traits::vector_traits<
+ VectorSELECT >::value_type& s, typename traits::vector_traits<
+ VectorSELECT >::value_type& sep ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ trsen_impl< value_type >::compute( job, compq, select, t, q, w, m, s,
+ sep, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSNA_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -86,6 +88,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
@@ -168,6 +171,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
@@ -249,7 +253,7 @@
 inline integer_t trsna( char const job, char const howmny,
         VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
         VectorS& s, VectorSEP& sep, integer_t const mm, integer_t& m,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits<
             VectorSELECT >::value_type value_type;
     integer_t info(0);
@@ -258,6 +262,20 @@
     return info;
 }
 
+// template function to call trsna, default workspace type
+template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
+ typename MatrixVR, typename VectorS, typename VectorSEP >
+inline integer_t trsna( char const job, char const howmny,
+ VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
+ VectorS& s, VectorSEP& sep, integer_t const mm, integer_t& m ) {
+ typedef typename traits::vector_traits<
+ VectorSELECT >::value_type value_type;
+ integer_t info(0);
+ trsna_impl< value_type >::compute( job, howmny, select, t, vl, vr, s,
+ sep, mm, m, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSYL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -77,6 +79,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC >
@@ -110,6 +114,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRI_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // templated specialization
     template< typename MatrixA >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -68,6 +70,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TZRZF_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -72,6 +74,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -129,6 +132,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -183,14 +187,23 @@
 
 // template function to call tzrzf
 template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline integer_t tzrzf( MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+inline integer_t tzrzf( MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     tzrzf_impl< value_type >::compute( a, tau, info, work );
     return info;
 }
 
+// template function to call tzrzf, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t tzrzf( MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ tzrzf_impl< value_type >::compute( a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGBR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -111,7 +114,7 @@
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t ungbr( char const vect, integer_t const m,
         integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ungbr_impl< value_type >::compute( vect, m, n, k, a, tau, info,
@@ -119,6 +122,17 @@
     return info;
 }
 
+// template function to call ungbr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t ungbr( char const vect, integer_t const m,
+ integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ungbr_impl< value_type >::compute( vect, m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGHR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -110,14 +113,24 @@
 // template function to call unghr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t unghr( integer_t const n, integer_t const ilo,
- integer_t const ihi, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const ihi, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unghr_impl< value_type >::compute( n, ilo, ihi, a, tau, info, work );
     return info;
 }
 
+// template function to call unghr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t unghr( integer_t const n, integer_t const ilo,
+ integer_t const ihi, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unghr_impl< value_type >::compute( n, ilo, ihi, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGLQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -111,14 +114,24 @@
 // template function to call unglq
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t unglq( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unglq_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call unglq, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t unglq( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unglq_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -111,14 +114,24 @@
 // template function to call ungql
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t ungql( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ungql_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call ungql, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t ungql( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ungql_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -111,14 +114,24 @@
 // template function to call ungqr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t ungqr( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ungqr_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call ungqr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t ungqr( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ungqr_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGRQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -111,14 +114,24 @@
 // template function to call ungrq
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t ungrq( integer_t const m, integer_t const n,
- integer_t const k, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ integer_t const k, MatrixA& a, VectorTAU& tau, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ungrq_impl< value_type >::compute( m, n, k, a, tau, info, work );
     return info;
 }
 
+// template function to call ungrq, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t ungrq( integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ungrq_impl< value_type >::compute( m, n, k, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
@@ -112,13 +115,23 @@
 // template function to call ungtr
 template< typename MatrixA, typename VectorTAU, typename Workspace >
 inline integer_t ungtr( integer_t const n, MatrixA& a, VectorTAU& tau,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ungtr_impl< value_type >::compute( n, a, tau, info, work );
     return info;
 }
 
+// template function to call ungtr, default workspace type
+template< typename MatrixA, typename VectorTAU >
+inline integer_t ungtr( integer_t const n, MatrixA& a, VectorTAU& tau ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ungtr_impl< value_type >::compute( n, a, tau, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMBR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -61,6 +63,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -137,7 +140,7 @@
         typename Workspace >
 inline integer_t unmbr( char const vect, char const side,
         char const trans, integer_t const k, MatrixA& a, VectorTAU& tau,
- MatrixC& c, Workspace work = optimal_workspace() ) {
+ MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmbr_impl< value_type >::compute( vect, side, trans, k, a, tau, c,
@@ -145,6 +148,18 @@
     return info;
 }
 
+// template function to call unmbr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmbr( char const vect, char const side,
+ char const trans, integer_t const k, MatrixA& a, VectorTAU& tau,
+ MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmbr_impl< value_type >::compute( vect, side, trans, k, a, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMHR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -61,6 +63,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -138,7 +141,7 @@
         typename Workspace >
 inline integer_t unmhr( char const side, char const trans,
         integer_t const ilo, integer_t const ihi, MatrixA& a, VectorTAU& tau,
- MatrixC& c, Workspace work = optimal_workspace() ) {
+ MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmhr_impl< value_type >::compute( side, trans, ilo, ihi, a, tau, c,
@@ -146,6 +149,18 @@
     return info;
 }
 
+// template function to call unmhr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmhr( char const side, char const trans,
+ integer_t const ilo, integer_t const ihi, MatrixA& a, VectorTAU& tau,
+ MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmhr_impl< value_type >::compute( side, trans, ilo, ihi, a, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMLQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -132,7 +135,7 @@
         typename Workspace >
 inline integer_t unmlq( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmlq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -140,6 +143,17 @@
     return info;
 }
 
+// template function to call unmlq, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmlq( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmlq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQL_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -131,7 +134,7 @@
         typename Workspace >
 inline integer_t unmql( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmql_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -139,6 +142,17 @@
     return info;
 }
 
+// template function to call unmql, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmql( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmql_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -131,7 +134,7 @@
         typename Workspace >
 inline integer_t unmqr( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmqr_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -139,6 +142,17 @@
     return info;
 }
 
+// template function to call unmqr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmqr( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmqr_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRQ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -132,7 +135,7 @@
         typename Workspace >
 inline integer_t unmrq( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmrq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -140,6 +143,17 @@
     return info;
 }
 
+// template function to call unmrq, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmrq( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmrq_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRZ_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -129,7 +132,7 @@
         typename Workspace >
 inline integer_t unmrz( char const side, char const trans,
         integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmrz_impl< value_type >::compute( side, trans, k, a, tau, c, info,
@@ -137,6 +140,17 @@
     return info;
 }
 
+// template function to call unmrz, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmrz( char const side, char const trans,
+ integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmrz_impl< value_type >::compute( side, trans, k, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
@@ -132,7 +135,7 @@
 template< typename MatrixA, typename VectorTAU, typename MatrixC,
         typename Workspace >
 inline integer_t unmtr( char const side, char const trans, MatrixA& a,
- VectorTAU& tau, MatrixC& c, Workspace work = optimal_workspace() ) {
+ VectorTAU& tau, MatrixC& c, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     unmtr_impl< value_type >::compute( side, trans, a, tau, c, info,
@@ -140,6 +143,17 @@
     return info;
 }
 
+// template function to call unmtr, default workspace type
+template< typename MatrixA, typename VectorTAU, typename MatrixC >
+inline integer_t unmtr( char const side, char const trans, MatrixA& a,
+ VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ unmtr_impl< value_type >::compute( side, trans, a, tau, c, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPGTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ,
@@ -111,13 +114,24 @@
 template< typename VectorAP, typename VectorTAU, typename MatrixQ,
         typename Workspace >
 inline integer_t upgtr( char const uplo, VectorAP& ap, VectorTAU& tau,
- MatrixQ& q, Workspace work = optimal_workspace() ) {
+ MatrixQ& q, Workspace work ) {
     typedef typename traits::vector_traits< VectorAP >::value_type value_type;
     integer_t info(0);
     upgtr_impl< value_type >::compute( uplo, ap, tau, q, info, work );
     return info;
 }
 
+// template function to call upgtr, default workspace type
+template< typename VectorAP, typename VectorTAU, typename MatrixQ >
+inline integer_t upgtr( char const uplo, VectorAP& ap, VectorTAU& tau,
+ MatrixQ& q ) {
+ typedef typename traits::vector_traits< VectorAP >::value_type value_type;
+ integer_t info(0);
+ upgtr_impl< value_type >::compute( uplo, ap, tau, q, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPMTR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC,
@@ -114,7 +117,7 @@
         typename Workspace >
 inline integer_t upmtr( char const side, char const uplo,
         char const trans, VectorAP& ap, VectorTAU& tau, MatrixC& c,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorAP >::value_type value_type;
     integer_t info(0);
     upmtr_impl< value_type >::compute( side, uplo, trans, ap, tau, c,
@@ -122,6 +125,17 @@
     return info;
 }
 
+// template function to call upmtr, default workspace type
+template< typename VectorAP, typename VectorTAU, typename MatrixC >
+inline integer_t upmtr( char const side, char const uplo,
+ char const trans, VectorAP& ap, VectorTAU& tau, MatrixC& c ) {
+ typedef typename traits::vector_traits< VectorAP >::value_type value_type;
+ integer_t info(0);
+ upmtr_impl< value_type >::compute( side, uplo, trans, ap, tau, c,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_CGESV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -50,6 +52,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
@@ -124,13 +128,25 @@
 template< typename MatrixA, typename VectorIPIV, typename MatrixB,
         typename MatrixX, typename Workspace >
 inline integer_t cgesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
- MatrixX& x, integer_t& iter, Workspace work = optimal_workspace() ) {
+ MatrixX& x, integer_t& iter, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     cgesv_impl< value_type >::compute( a, ipiv, b, x, iter, info, work );
     return info;
 }
 
+// template function to call cgesv, default workspace type
+template< typename MatrixA, typename VectorIPIV, typename MatrixB,
+ typename MatrixX >
+inline integer_t cgesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
+ MatrixX& x, integer_t& iter ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ cgesv_impl< value_type >::compute( a, ipiv, b, x, iter, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -64,6 +66,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -97,6 +99,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
@@ -206,6 +210,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
@@ -317,8 +323,7 @@
         MatrixAB& ab, MatrixAFB& afb, VectorIPIV& ipiv, char& equed,
         VectorR& r, VectorC& c, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixAB >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     gbsvx_impl< value_type >::compute( fact, trans, n, kl, ku, ab, afb,
@@ -326,6 +331,24 @@
     return info;
 }
 
+// template function to call gbsvx, default workspace type
+template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
+ typename VectorR, typename VectorC, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t gbsvx( char const fact, char const trans,
+ integer_t const n, integer_t const kl, integer_t const ku,
+ MatrixAB& ab, MatrixAFB& afb, VectorIPIV& ipiv, char& equed,
+ VectorR& r, VectorC& c, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixAB >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ gbsvx_impl< value_type >::compute( fact, trans, n, kl, ku, ab, afb,
+ ipiv, equed, r, c, b, x, rcond, ferr, berr, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEES_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -86,6 +88,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
@@ -178,6 +181,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS,
@@ -273,19 +277,32 @@
         typename MatrixVS, typename Workspace >
 inline integer_t gees( char const jobvs, char const sort,
         logical_t* select, MatrixA& a, integer_t& sdim, VectorWR& wr,
- VectorWI& wi, MatrixVS& vs, Workspace work = optimal_workspace() ) {
+ VectorWI& wi, MatrixVS& vs, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gees_impl< value_type >::compute( jobvs, sort, select, a, sdim, wr,
             wi, vs, info, work );
     return info;
 }
+
+// template function to call gees, default workspace type
+template< typename MatrixA, typename VectorWR, typename VectorWI,
+ typename MatrixVS >
+inline integer_t gees( char const jobvs, char const sort,
+ logical_t* select, MatrixA& a, integer_t& sdim, VectorWR& wr,
+ VectorWI& wi, MatrixVS& vs ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gees_impl< value_type >::compute( jobvs, sort, select, a, sdim, wr,
+ wi, vs, info, optimal_workspace() );
+ return info;
+}
 // template function to call gees
 template< typename MatrixA, typename VectorW, typename MatrixVS,
         typename Workspace >
 inline integer_t gees( char const jobvs, char const sort,
         logical_t* select, MatrixA& a, integer_t& sdim, VectorW& w,
- MatrixVS& vs, Workspace work = optimal_workspace() ) {
+ MatrixVS& vs, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gees_impl< value_type >::compute( jobvs, sort, select, a, sdim, w,
@@ -293,6 +310,18 @@
     return info;
 }
 
+// template function to call gees, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixVS >
+inline integer_t gees( char const jobvs, char const sort,
+ logical_t* select, MatrixA& a, integer_t& sdim, VectorW& w,
+ MatrixVS& vs ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gees_impl< value_type >::compute( jobvs, sort, select, a, sdim, w,
+ vs, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEESX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -90,6 +92,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
@@ -207,6 +210,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS,
@@ -315,13 +319,28 @@
         VectorWR& wr, VectorWI& wi, MatrixVS& vs,
         typename traits::matrix_traits< MatrixA >::value_type& rconde,
         typename traits::matrix_traits< MatrixA >::value_type& rcondv,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geesx_impl< value_type >::compute( jobvs, sort, select, sense, a,
             sdim, wr, wi, vs, rconde, rcondv, info, work );
     return info;
 }
+
+// template function to call geesx, default workspace type
+template< typename MatrixA, typename VectorWR, typename VectorWI,
+ typename MatrixVS >
+inline integer_t geesx( char const jobvs, char const sort,
+ logical_t* select, char const sense, MatrixA& a, integer_t& sdim,
+ VectorWR& wr, VectorWI& wi, MatrixVS& vs,
+ typename traits::matrix_traits< MatrixA >::value_type& rconde,
+ typename traits::matrix_traits< MatrixA >::value_type& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geesx_impl< value_type >::compute( jobvs, sort, select, sense, a,
+ sdim, wr, wi, vs, rconde, rcondv, info, optimal_workspace() );
+ return info;
+}
 // template function to call geesx
 template< typename MatrixA, typename VectorW, typename MatrixVS,
         typename Workspace >
@@ -329,7 +348,7 @@
         logical_t* select, char const sense, MatrixA& a, integer_t& sdim,
         VectorW& w, MatrixVS& vs, typename traits::matrix_traits<
         MatrixA >::value_type& rconde, typename traits::matrix_traits<
- MatrixA >::value_type& rcondv, Workspace work = optimal_workspace() ) {
+ MatrixA >::value_type& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geesx_impl< value_type >::compute( jobvs, sort, select, sense, a,
@@ -337,6 +356,20 @@
     return info;
 }
 
+// template function to call geesx, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixVS >
+inline integer_t geesx( char const jobvs, char const sort,
+ logical_t* select, char const sense, MatrixA& a, integer_t& sdim,
+ VectorW& w, MatrixVS& vs, typename traits::matrix_traits<
+ MatrixA >::value_type& rconde, typename traits::matrix_traits<
+ MatrixA >::value_type& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geesx_impl< value_type >::compute( jobvs, sort, select, sense, a,
+ sdim, w, vs, rconde, rcondv, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -85,6 +87,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
@@ -170,6 +173,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVL,
@@ -257,19 +261,30 @@
         typename MatrixVL, typename MatrixVR, typename Workspace >
 inline integer_t geev( char const jobvl, char const jobvr, MatrixA& a,
         VectorWR& wr, VectorWI& wi, MatrixVL& vl, MatrixVR& vr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geev_impl< value_type >::compute( jobvl, jobvr, a, wr, wi, vl, vr,
             info, work );
     return info;
 }
+
+// template function to call geev, default workspace type
+template< typename MatrixA, typename VectorWR, typename VectorWI,
+ typename MatrixVL, typename MatrixVR >
+inline integer_t geev( char const jobvl, char const jobvr, MatrixA& a,
+ VectorWR& wr, VectorWI& wi, MatrixVL& vl, MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geev_impl< value_type >::compute( jobvl, jobvr, a, wr, wi, vl, vr,
+ info, optimal_workspace() );
+ return info;
+}
 // template function to call geev
 template< typename MatrixA, typename VectorW, typename MatrixVL,
         typename MatrixVR, typename Workspace >
 inline integer_t geev( char const jobvl, char const jobvr, MatrixA& a,
- VectorW& w, MatrixVL& vl, MatrixVR& vr,
- Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixVL& vl, MatrixVR& vr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geev_impl< value_type >::compute( jobvl, jobvr, a, w, vl, vr, info,
@@ -277,6 +292,18 @@
     return info;
 }
 
+// template function to call geev, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixVL,
+ typename MatrixVR >
+inline integer_t geev( char const jobvl, char const jobvr, MatrixA& a,
+ VectorW& w, MatrixVL& vl, MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geev_impl< value_type >::compute( jobvl, jobvr, a, w, vl, vr, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -96,6 +98,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
@@ -241,6 +244,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVL,
@@ -369,7 +373,7 @@
         VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t& ilo,
         integer_t& ihi, VectorSCALE& scale, typename traits::matrix_traits<
         MatrixA >::value_type& abnrm, VectorRCONDE& rconde,
- VectorRCONDV& rcondv, Workspace work = optimal_workspace() ) {
+ VectorRCONDV& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a,
@@ -377,6 +381,24 @@
             work );
     return info;
 }
+
+// template function to call geevx, default workspace type
+template< typename MatrixA, typename VectorWR, typename VectorWI,
+ typename MatrixVL, typename MatrixVR, typename VectorSCALE,
+ typename VectorRCONDE, typename VectorRCONDV >
+inline integer_t geevx( char const balanc, char const jobvl,
+ char const jobvr, char const sense, MatrixA& a, VectorWR& wr,
+ VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t& ilo,
+ integer_t& ihi, VectorSCALE& scale, typename traits::matrix_traits<
+ MatrixA >::value_type& abnrm, VectorRCONDE& rconde,
+ VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a,
+ wr, wi, vl, vr, ilo, ihi, scale, abnrm, rconde, rcondv, info,
+ optimal_workspace() );
+ return info;
+}
 // template function to call geevx
 template< typename MatrixA, typename VectorW, typename MatrixVL,
         typename MatrixVR, typename VectorSCALE, typename VectorRCONDE,
@@ -386,7 +408,7 @@
         MatrixVL& vl, MatrixVR& vr, integer_t& ilo, integer_t& ihi,
         VectorSCALE& scale, typename traits::matrix_traits<
         MatrixA >::value_type& abnrm, VectorRCONDE& rconde,
- VectorRCONDV& rcondv, Workspace work = optimal_workspace() ) {
+ VectorRCONDV& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     geevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, w,
@@ -394,6 +416,24 @@
     return info;
 }
 
+// template function to call geevx, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixVL,
+ typename MatrixVR, typename VectorSCALE, typename VectorRCONDE,
+ typename VectorRCONDV >
+inline integer_t geevx( char const balanc, char const jobvl,
+ char const jobvr, char const sense, MatrixA& a, VectorW& w,
+ MatrixVL& vl, MatrixVR& vr, integer_t& ilo, integer_t& ihi,
+ VectorSCALE& scale, typename traits::matrix_traits<
+ MatrixA >::value_type& abnrm, VectorRCONDE& rconde,
+ VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ geevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, w,
+ vl, vr, ilo, ihi, scale, abnrm, rconde, rcondv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -90,6 +92,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
@@ -189,6 +193,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -291,21 +297,34 @@
         typename MatrixVR, typename Workspace >
 inline integer_t gegv( char const jobvl, char const jobvr, MatrixA& a,
         MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixVL& vl, MatrixVR& vr,
- Workspace work = optimal_workspace() ) {
+ VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gegv_impl< value_type >::compute( jobvl, jobvr, a, b, alphar,
             alphai, beta, vl, vr, info, work );
     return info;
 }
+
+// template function to call gegv, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixVL,
+ typename MatrixVR >
+inline integer_t gegv( char const jobvl, char const jobvr, MatrixA& a,
+ MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixVL& vl, MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gegv_impl< value_type >::compute( jobvl, jobvr, a, b, alphar,
+ alphai, beta, vl, vr, info, optimal_workspace() );
+ return info;
+}
 // template function to call gegv
 template< typename MatrixA, typename MatrixB, typename VectorALPHA,
         typename VectorBETA, typename MatrixVL, typename MatrixVR,
         typename Workspace >
 inline integer_t gegv( char const jobvl, char const jobvr, MatrixA& a,
         MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl,
- MatrixVR& vr, Workspace work = optimal_workspace() ) {
+ MatrixVR& vr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gegv_impl< value_type >::compute( jobvl, jobvr, a, b, alpha, beta,
@@ -313,6 +332,19 @@
     return info;
 }
 
+// template function to call gegv, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixVL, typename MatrixVR >
+inline integer_t gegv( char const jobvl, char const jobvr, MatrixA& a,
+ MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl,
+ MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gegv_impl< value_type >::compute( jobvl, jobvr, a, b, alpha, beta,
+ vl, vr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -78,6 +80,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename WORK >
@@ -145,6 +149,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename WORK >
@@ -210,13 +216,23 @@
 // template function to call gels
 template< typename MatrixA, typename MatrixB, typename Workspace >
 inline integer_t gels( char const trans, MatrixA& a, MatrixB& b,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gels_impl< value_type >::compute( trans, a, b, info, work );
     return info;
 }
 
+// template function to call gels, default workspace type
+template< typename MatrixA, typename MatrixB >
+inline integer_t gels( char const trans, MatrixA& a, MatrixB& b ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gels_impl< value_type >::compute( trans, a, b, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,8 +15,10 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorS,
@@ -189,6 +193,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorS,
@@ -303,13 +309,25 @@
         typename Workspace >
 inline integer_t gelsd( MatrixA& a, MatrixB& b, VectorS& s,
         typename traits::matrix_traits< MatrixA >::value_type const rcond,
- integer_t& rank, Workspace work = optimal_workspace() ) {
+ integer_t& rank, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gelsd_impl< value_type >::compute( a, b, s, rcond, rank, info, work );
     return info;
 }
 
+// template function to call gelsd, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorS >
+inline integer_t gelsd( MatrixA& a, MatrixB& b, VectorS& s,
+ typename traits::matrix_traits< MatrixA >::value_type const rcond,
+ integer_t& rank ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gelsd_impl< value_type >::compute( a, b, s, rcond, rank, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSS_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -81,6 +83,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorS,
@@ -160,6 +164,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorS,
@@ -253,13 +259,25 @@
         typename Workspace >
 inline integer_t gelss( MatrixA& a, MatrixB& b, VectorS& s,
         typename traits::matrix_traits< MatrixA >::value_type const rcond,
- integer_t& rank, Workspace work = optimal_workspace() ) {
+ integer_t& rank, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gelss_impl< value_type >::compute( a, b, s, rcond, rank, info, work );
     return info;
 }
 
+// template function to call gelss, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorS >
+inline integer_t gelss( MatrixA& a, MatrixB& b, VectorS& s,
+ typename traits::matrix_traits< MatrixA >::value_type const rcond,
+ integer_t& rank ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gelss_impl< value_type >::compute( a, b, s, rcond, rank, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSY_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorJPVT,
@@ -154,6 +158,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorJPVT,
@@ -239,7 +245,7 @@
         typename Workspace >
 inline integer_t gelsy( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
         typename traits::matrix_traits< MatrixA >::value_type const rcond,
- integer_t& rank, Workspace work = optimal_workspace() ) {
+ integer_t& rank, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gelsy_impl< value_type >::compute( a, b, jpvt, rcond, rank, info,
@@ -247,6 +253,18 @@
     return info;
 }
 
+// template function to call gelsy, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorJPVT >
+inline integer_t gelsy( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
+ typename traits::matrix_traits< MatrixA >::value_type const rcond,
+ integer_t& rank ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gelsy_impl< value_type >::compute( a, b, jpvt, rcond, rank, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESDD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -83,6 +85,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorS, typename MatrixU,
@@ -169,6 +172,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorS, typename MatrixU,
@@ -277,13 +281,25 @@
 template< typename MatrixA, typename VectorS, typename MatrixU,
         typename MatrixVT, typename Workspace >
 inline integer_t gesdd( char const jobz, MatrixA& a, VectorS& s,
- MatrixU& u, MatrixVT& vt, Workspace work = optimal_workspace() ) {
+ MatrixU& u, MatrixVT& vt, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gesdd_impl< value_type >::compute( jobz, a, s, u, vt, info, work );
     return info;
 }
 
+// template function to call gesdd, default workspace type
+template< typename MatrixA, typename VectorS, typename MatrixU,
+ typename MatrixVT >
+inline integer_t gesdd( char const jobz, MatrixA& a, VectorS& s,
+ MatrixU& u, MatrixVT& vt ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gesdd_impl< value_type >::compute( jobz, a, s, u, vt, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorS, typename MatrixU,
@@ -162,6 +165,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorS, typename MatrixU,
@@ -258,8 +262,7 @@
 template< typename MatrixA, typename VectorS, typename MatrixU,
         typename MatrixVT, typename Workspace >
 inline integer_t gesvd( char const jobu, char const jobvt, MatrixA& a,
- VectorS& s, MatrixU& u, MatrixVT& vt,
- Workspace work = optimal_workspace() ) {
+ VectorS& s, MatrixU& u, MatrixVT& vt, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gesvd_impl< value_type >::compute( jobu, jobvt, a, s, u, vt, info,
@@ -267,6 +270,18 @@
     return info;
 }
 
+// template function to call gesvd, default workspace type
+template< typename MatrixA, typename VectorS, typename MatrixU,
+ typename MatrixVT >
+inline integer_t gesvd( char const jobu, char const jobvt, MatrixA& a,
+ VectorS& s, MatrixU& u, MatrixVT& vt ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gesvd_impl< value_type >::compute( jobu, jobvt, a, s, u, vt, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -91,6 +93,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -201,6 +205,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -312,7 +318,7 @@
         MatrixAF& af, VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c,
         MatrixB& b, MatrixX& x, typename traits::matrix_traits<
         MatrixA >::value_type& rcond, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gesvx_impl< value_type >::compute( fact, trans, a, af, ipiv, equed,
@@ -320,6 +326,21 @@
     return info;
 }
 
+// template function to call gesvx, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename VectorR, typename VectorC, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t gesvx( char const fact, char const trans, MatrixA& a,
+ MatrixAF& af, VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c,
+ MatrixB& b, MatrixX& x, typename traits::matrix_traits<
+ MatrixA >::value_type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gesvx_impl< value_type >::compute( fact, trans, a, af, ipiv, equed,
+ r, c, b, x, rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGES_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -102,6 +104,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
@@ -221,6 +225,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -347,14 +353,29 @@
 inline integer_t gges( char const jobvsl, char const jobvsr,
         char const sort, logical_t* selctg, MatrixA& a, MatrixB& b,
         integer_t& sdim, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr,
- Workspace work = optimal_workspace() ) {
+ VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gges_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg, a,
             b, sdim, alphar, alphai, beta, vsl, vsr, info, work );
     return info;
 }
+
+// template function to call gges, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixVSL,
+ typename MatrixVSR >
+inline integer_t gges( char const jobvsl, char const jobvsr,
+ char const sort, logical_t* selctg, MatrixA& a, MatrixB& b,
+ integer_t& sdim, VectorALPHAR& alphar, VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gges_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg, a,
+ b, sdim, alphar, alphai, beta, vsl, vsr, info,
+ optimal_workspace() );
+ return info;
+}
 // template function to call gges
 template< typename MatrixA, typename MatrixB, typename VectorALPHA,
         typename VectorBETA, typename MatrixVSL, typename MatrixVSR,
@@ -362,7 +383,7 @@
 inline integer_t gges( char const jobvsl, char const jobvsr,
         char const sort, logical_t* selctg, MatrixA& a, MatrixB& b,
         integer_t& sdim, VectorALPHA& alpha, VectorBETA& beta, MatrixVSL& vsl,
- MatrixVSR& vsr, Workspace work = optimal_workspace() ) {
+ MatrixVSR& vsr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gges_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg, a,
@@ -370,6 +391,20 @@
     return info;
 }
 
+// template function to call gges, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixVSL, typename MatrixVSR >
+inline integer_t gges( char const jobvsl, char const jobvsr,
+ char const sort, logical_t* selctg, MatrixA& a, MatrixB& b,
+ integer_t& sdim, VectorALPHA& alpha, VectorBETA& beta, MatrixVSL& vsl,
+ MatrixVSR& vsr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gges_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg, a,
+ b, sdim, alpha, beta, vsl, vsr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGESX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -108,6 +110,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
@@ -265,6 +269,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -427,7 +433,7 @@
         MatrixB& b, integer_t& sdim, VectorALPHAR& alphar,
         VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
         MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggesx_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg,
@@ -435,6 +441,23 @@
             info, work );
     return info;
 }
+
+// template function to call ggesx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixVSL,
+ typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV >
+inline integer_t ggesx( char const jobvsl, char const jobvsr,
+ char const sort, logical_t* selctg, char const sense, MatrixA& a,
+ MatrixB& b, integer_t& sdim, VectorALPHAR& alphar,
+ VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
+ MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggesx_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg,
+ sense, a, b, sdim, alphar, alphai, beta, vsl, vsr, rconde, rcondv,
+ info, optimal_workspace() );
+ return info;
+}
 // template function to call ggesx
 template< typename MatrixA, typename MatrixB, typename VectorALPHA,
         typename VectorBETA, typename MatrixVSL, typename MatrixVSR,
@@ -443,7 +466,7 @@
         char const sort, logical_t* selctg, char const sense, MatrixA& a,
         MatrixB& b, integer_t& sdim, VectorALPHA& alpha, VectorBETA& beta,
         MatrixVSL& vsl, MatrixVSR& vsr, VectorRCONDE& rconde,
- VectorRCONDV& rcondv, Workspace work = optimal_workspace() ) {
+ VectorRCONDV& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggesx_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg,
@@ -452,6 +475,23 @@
     return info;
 }
 
+// template function to call ggesx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixVSL, typename MatrixVSR,
+ typename VectorRCONDE, typename VectorRCONDV >
+inline integer_t ggesx( char const jobvsl, char const jobvsr,
+ char const sort, logical_t* selctg, char const sense, MatrixA& a,
+ MatrixB& b, integer_t& sdim, VectorALPHA& alpha, VectorBETA& beta,
+ MatrixVSL& vsl, MatrixVSR& vsr, VectorRCONDE& rconde,
+ VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggesx_impl< value_type >::compute( jobvsl, jobvsr, sort, selctg,
+ sense, a, b, sdim, alpha, beta, vsl, vsr, rconde, rcondv, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -90,6 +92,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
@@ -189,6 +193,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -291,21 +297,34 @@
         typename MatrixVR, typename Workspace >
 inline integer_t ggev( char const jobvl, char const jobvr, MatrixA& a,
         MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixVL& vl, MatrixVR& vr,
- Workspace work = optimal_workspace() ) {
+ VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggev_impl< value_type >::compute( jobvl, jobvr, a, b, alphar,
             alphai, beta, vl, vr, info, work );
     return info;
 }
+
+// template function to call ggev, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixVL,
+ typename MatrixVR >
+inline integer_t ggev( char const jobvl, char const jobvr, MatrixA& a,
+ MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixVL& vl, MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggev_impl< value_type >::compute( jobvl, jobvr, a, b, alphar,
+ alphai, beta, vl, vr, info, optimal_workspace() );
+ return info;
+}
 // template function to call ggev
 template< typename MatrixA, typename MatrixB, typename VectorALPHA,
         typename VectorBETA, typename MatrixVL, typename MatrixVR,
         typename Workspace >
 inline integer_t ggev( char const jobvl, char const jobvr, MatrixA& a,
         MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl,
- MatrixVR& vr, Workspace work = optimal_workspace() ) {
+ MatrixVR& vr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggev_impl< value_type >::compute( jobvl, jobvr, a, b, alpha, beta,
@@ -313,6 +332,19 @@
     return info;
 }
 
+// template function to call ggev, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixVL, typename MatrixVR >
+inline integer_t ggev( char const jobvl, char const jobvr, MatrixA& a,
+ MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl,
+ MatrixVR& vr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggev_impl< value_type >::compute( jobvl, jobvr, a, b, alpha, beta,
+ vl, vr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -111,6 +113,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
@@ -286,6 +290,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -476,8 +482,7 @@
         VectorLSCALE& lscale, VectorRSCALE& rscale,
         typename traits::matrix_traits< MatrixA >::value_type& abnrm,
         typename traits::matrix_traits< MatrixA >::value_type& bbnrm,
- VectorRCONDE& rconde, VectorRCONDV& rcondv,
- Workspace work = optimal_workspace() ) {
+ VectorRCONDE& rconde, VectorRCONDV& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, b,
@@ -485,6 +490,27 @@
             bbnrm, rconde, rcondv, info, work );
     return info;
 }
+
+// template function to call ggevx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHAR,
+ typename VectorALPHAI, typename VectorBETA, typename MatrixVL,
+ typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE,
+ typename VectorRCONDE, typename VectorRCONDV >
+inline integer_t ggevx( char const balanc, char const jobvl,
+ char const jobvr, char const sense, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixVL& vl, MatrixVR& vr, integer_t& ilo, integer_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale,
+ typename traits::matrix_traits< MatrixA >::value_type& abnrm,
+ typename traits::matrix_traits< MatrixA >::value_type& bbnrm,
+ VectorRCONDE& rconde, VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, b,
+ alphar, alphai, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm,
+ bbnrm, rconde, rcondv, info, optimal_workspace() );
+ return info;
+}
 // template function to call ggevx
 template< typename MatrixA, typename MatrixB, typename VectorALPHA,
         typename VectorBETA, typename MatrixVL, typename MatrixVR,
@@ -497,7 +523,7 @@
         VectorRSCALE& rscale, typename traits::matrix_traits<
         MatrixA >::value_type& abnrm, typename traits::matrix_traits<
         MatrixA >::value_type& bbnrm, VectorRCONDE& rconde,
- VectorRCONDV& rcondv, Workspace work = optimal_workspace() ) {
+ VectorRCONDV& rcondv, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, b,
@@ -506,6 +532,27 @@
     return info;
 }
 
+// template function to call ggevx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixVL, typename MatrixVR,
+ typename VectorLSCALE, typename VectorRSCALE, typename VectorRCONDE,
+ typename VectorRCONDV >
+inline integer_t ggevx( char const balanc, char const jobvl,
+ char const jobvr, char const sense, MatrixA& a, MatrixB& b,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr,
+ integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale, typename traits::matrix_traits<
+ MatrixA >::value_type& abnrm, typename traits::matrix_traits<
+ MatrixA >::value_type& bbnrm, VectorRCONDE& rconde,
+ VectorRCONDV& rcondv ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggevx_impl< value_type >::compute( balanc, jobvl, jobvr, sense, a, b,
+ alpha, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm,
+ rconde, rcondv, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGGLM_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorD,
@@ -165,6 +169,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorD,
@@ -247,13 +253,25 @@
 template< typename MatrixA, typename MatrixB, typename VectorD,
         typename VectorX, typename VectorY, typename Workspace >
 inline integer_t ggglm( MatrixA& a, MatrixB& b, VectorD& d, VectorX& x,
- VectorY& y, Workspace work = optimal_workspace() ) {
+ VectorY& y, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggglm_impl< value_type >::compute( a, b, d, x, y, info, work );
     return info;
 }
 
+// template function to call ggglm, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorD,
+ typename VectorX, typename VectorY >
+inline integer_t ggglm( MatrixA& a, MatrixB& b, VectorD& d, VectorX& x,
+ VectorY& y ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggglm_impl< value_type >::compute( a, b, d, x, y, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGLSE_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -82,6 +84,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorC,
@@ -163,6 +167,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorC,
@@ -243,13 +249,25 @@
 template< typename MatrixA, typename MatrixB, typename VectorC,
         typename VectorD, typename VectorX, typename Workspace >
 inline integer_t gglse( MatrixA& a, MatrixB& b, VectorC& c, VectorD& d,
- VectorX& x, Workspace work = optimal_workspace() ) {
+ VectorX& x, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     gglse_impl< value_type >::compute( a, b, c, d, x, info, work );
     return info;
 }
 
+// template function to call gglse, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorC,
+ typename VectorD, typename VectorX >
+inline integer_t gglse( MatrixA& a, MatrixB& b, VectorC& c, VectorD& d,
+ VectorX& x ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ gglse_impl< value_type >::compute( a, b, c, d, x, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGSVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -99,6 +101,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -201,6 +205,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
@@ -311,7 +317,7 @@
 inline integer_t ggsvd( char const jobu, char const jobv,
         char const jobq, integer_t& k, integer_t& l, MatrixA& a, MatrixB& b,
         VectorALPHA& alpha, VectorBETA& beta, MatrixU& u, MatrixV& v,
- MatrixQ& q, Workspace work = optimal_workspace() ) {
+ MatrixQ& q, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     ggsvd_impl< value_type >::compute( jobu, jobv, jobq, k, l, a, b,
@@ -319,6 +325,21 @@
     return info;
 }
 
+// template function to call ggsvd, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorALPHA,
+ typename VectorBETA, typename MatrixU, typename MatrixV,
+ typename MatrixQ >
+inline integer_t ggsvd( char const jobu, char const jobv,
+ char const jobq, integer_t& k, integer_t& l, MatrixA& a, MatrixB& b,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixU& u, MatrixV& v,
+ MatrixQ& q ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ ggsvd_impl< value_type >::compute( jobu, jobv, jobq, k, l, a, b,
+ alpha, beta, u, v, q, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -64,6 +66,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -97,6 +99,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,
@@ -213,6 +217,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,
@@ -332,8 +338,7 @@
         VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
         typename traits::vector_traits< VectorDL >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::vector_traits< VectorDL >::value_type value_type;
     integer_t info(0);
     gtsvx_impl< value_type >::compute( fact, trans, n, dl, d, du, dlf,
@@ -341,6 +346,25 @@
     return info;
 }
 
+// template function to call gtsvx, default workspace type
+template< typename VectorDL, typename VectorD, typename VectorDU,
+ typename VectorDLF, typename VectorDF, typename VectorDUF,
+ typename VectorDU2, typename VectorIPIV, typename MatrixB,
+ typename MatrixX, typename VectorFERR, typename VectorBERR >
+inline integer_t gtsvx( char const fact, char const trans,
+ integer_t const n, VectorDL& dl, VectorD& d, VectorDU& du,
+ VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ typename traits::vector_traits< VectorDL >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::vector_traits< VectorDL >::value_type value_type;
+ integer_t info(0);
+ gtsvx_impl< value_type >::compute( fact, trans, n, dl, d, du, dlf,
+ df, duf, du2, ipiv, b, x, rcond, ferr, berr, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
@@ -118,7 +121,7 @@
         typename Workspace >
 inline integer_t hbev( char const jobz, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbev_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
@@ -126,6 +129,17 @@
     return info;
 }
 
+// template function to call hbev, default workspace type
+template< typename MatrixAB, typename VectorW, typename MatrixZ >
+inline integer_t hbev( char const jobz, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbev_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -61,6 +63,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
@@ -168,7 +171,7 @@
         typename Workspace >
 inline integer_t hbevd( char const jobz, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbevd_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
@@ -176,6 +179,17 @@
     return info;
 }
 
+// template function to call hbevd, default workspace type
+template< typename MatrixAB, typename VectorW, typename MatrixZ >
+inline integer_t hbevd( char const jobz, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbevd_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -66,6 +68,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixQ, typename VectorW,
@@ -160,7 +163,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAB >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbevx_impl< value_type >::compute( jobz, range, n, kd, ab, q, vl, vu,
@@ -168,6 +171,23 @@
     return info;
 }
 
+// template function to call hbevx, default workspace type
+template< typename MatrixAB, typename MatrixQ, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t hbevx( char const jobz, char const range,
+ integer_t const n, integer_t const kd, MatrixAB& ab, MatrixQ& q,
+ typename traits::matrix_traits< MatrixAB >::value_type const vl,
+ typename traits::matrix_traits< MatrixAB >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAB >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbevx_impl< value_type >::compute( jobz, range, n, kd, ab, q, vl, vu,
+ il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename VectorW,
@@ -133,7 +137,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t hbgv( char const jobz, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbgv_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
@@ -141,6 +145,19 @@
     return info;
 }
 
+// template function to call hbgv, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename VectorW,
+ typename MatrixZ >
+inline integer_t hbgv( char const jobz, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbgv_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -65,6 +67,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename VectorW,
@@ -184,7 +188,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t hbgvd( char const jobz, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbgvd_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
@@ -192,6 +196,19 @@
     return info;
 }
 
+// template function to call hbgvd, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename VectorW,
+ typename MatrixZ >
+inline integer_t hbgvd( char const jobz, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbgvd_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -70,6 +72,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixQ,
@@ -173,7 +177,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAB >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     hbgvx_impl< value_type >::compute( jobz, range, n, ka, kb, ab, bb, q,
@@ -181,6 +185,25 @@
     return info;
 }
 
+// template function to call hbgvx, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename MatrixQ,
+ typename VectorW, typename MatrixZ, typename VectorIFAIL >
+inline integer_t hbgvx( char const jobz, char const range,
+ integer_t const n, integer_t const ka, integer_t const kb,
+ MatrixAB& ab, MatrixBB& bb, MatrixQ& q,
+ typename traits::matrix_traits< MatrixAB >::value_type const vl,
+ typename traits::matrix_traits< MatrixAB >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAB >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ hbgvx_impl< value_type >::compute( jobz, range, n, ka, kb, ab, bb, q,
+ vl, vu, il, iu, abstol, m, w, z, ifail, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename WORK,
@@ -119,13 +122,23 @@
 // template function to call heev
 template< typename MatrixA, typename VectorW, typename Workspace >
 inline integer_t heev( char const jobz, MatrixA& a, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     heev_impl< value_type >::compute( jobz, a, w, info, work );
     return info;
 }
 
+// template function to call heev, default workspace type
+template< typename MatrixA, typename VectorW >
+inline integer_t heev( char const jobz, MatrixA& a, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ heev_impl< value_type >::compute( jobz, a, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename WORK,
@@ -157,13 +160,23 @@
 // template function to call heevd
 template< typename MatrixA, typename VectorW, typename Workspace >
 inline integer_t heevd( char const jobz, MatrixA& a, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     heevd_impl< value_type >::compute( jobz, a, w, info, work );
     return info;
 }
 
+// template function to call heevd, default workspace type
+template< typename MatrixA, typename VectorW >
+inline integer_t heevd( char const jobz, MatrixA& a, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ heevd_impl< value_type >::compute( jobz, a, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -67,6 +69,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixZ,
@@ -177,7 +180,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     heevr_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
@@ -185,6 +188,22 @@
     return info;
 }
 
+// template function to call heevr, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixZ,
+ typename VectorISUPPZ >
+inline integer_t heevr( char const jobz, char const range, MatrixA& a,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ heevr_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
+ abstol, m, w, z, isuppz, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -65,6 +67,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixZ,
@@ -173,7 +176,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     heevx_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
@@ -181,6 +184,22 @@
     return info;
 }
 
+// template function to call heevx, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixZ,
+ typename VectorIFAIL >
+inline integer_t heevx( char const jobz, char const range, MatrixA& a,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ heevx_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
+ abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -132,7 +136,7 @@
         typename Workspace >
 inline integer_t hegv( integer_t const itype, char const jobz,
         integer_t const n, MatrixA& a, MatrixB& b, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hegv_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
@@ -140,6 +144,17 @@
     return info;
 }
 
+// template function to call hegv, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW >
+inline integer_t hegv( integer_t const itype, char const jobz,
+ integer_t const n, MatrixA& a, MatrixB& b, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hegv_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -61,6 +63,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -168,7 +172,7 @@
         typename Workspace >
 inline integer_t hegvd( integer_t const itype, char const jobz,
         integer_t const n, MatrixA& a, MatrixB& b, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hegvd_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
@@ -176,6 +180,17 @@
     return info;
 }
 
+// template function to call hegvd, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW >
+inline integer_t hegvd( integer_t const itype, char const jobz,
+ integer_t const n, MatrixA& a, MatrixB& b, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hegvd_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -70,6 +72,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -179,7 +183,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hegvx_impl< value_type >::compute( itype, jobz, range, n, a, b, vl,
@@ -187,6 +191,23 @@
     return info;
 }
 
+// template function to call hegvx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t hegvx( integer_t const itype, char const jobz,
+ char const range, integer_t const n, MatrixA& a, MatrixB& b,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hegvx_impl< value_type >::compute( itype, jobz, range, n, a, b, vl,
+ vu, il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
@@ -118,13 +122,23 @@
 template< typename MatrixA, typename VectorIPIV, typename MatrixB,
         typename Workspace >
 inline integer_t hesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hesv_impl< value_type >::compute( a, ipiv, b, info, work );
     return info;
 }
 
+// template function to call hesv, default workspace type
+template< typename MatrixA, typename VectorIPIV, typename MatrixB >
+inline integer_t hesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hesv_impl< value_type >::compute( a, ipiv, b, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -65,6 +67,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -177,8 +181,7 @@
 inline integer_t hesvx( char const fact, MatrixA& a, MatrixAF& af,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     hesvx_impl< value_type >::compute( fact, a, af, ipiv, b, x, rcond,
@@ -186,6 +189,21 @@
     return info;
 }
 
+// template function to call hesvx, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t hesvx( char const fact, MatrixA& a, MatrixAF& af,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ hesvx_impl< value_type >::compute( fact, a, af, ipiv, b, x, rcond,
+ ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -111,13 +114,24 @@
 template< typename MatrixAP, typename VectorW, typename MatrixZ,
         typename Workspace >
 inline integer_t hpev( char const jobz, integer_t const n, MatrixAP& ap,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpev_impl< value_type >::compute( jobz, n, ap, w, z, info, work );
     return info;
 }
 
+// template function to call hpev, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ >
+inline integer_t hpev( char const jobz, integer_t const n, MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpev_impl< value_type >::compute( jobz, n, ap, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -160,13 +163,24 @@
 template< typename MatrixAP, typename VectorW, typename MatrixZ,
         typename Workspace >
 inline integer_t hpevd( char const jobz, integer_t const n, MatrixAP& ap,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpevd_impl< value_type >::compute( jobz, n, ap, w, z, info, work );
     return info;
 }
 
+// template function to call hpevd, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ >
+inline integer_t hpevd( char const jobz, integer_t const n, MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpevd_impl< value_type >::compute( jobz, n, ap, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -61,6 +63,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -145,8 +148,7 @@
         MatrixAP >::value_type const vu, integer_t const il,
         integer_t const iu, typename traits::matrix_traits<
         MatrixAP >::value_type const abstol, integer_t& m, VectorW& w,
- MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpevx_impl< value_type >::compute( jobz, range, n, ap, vl, vu, il,
@@ -154,6 +156,23 @@
     return info;
 }
 
+// template function to call hpevx, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ,
+ typename VectorIFAIL >
+inline integer_t hpevx( char const jobz, char const range,
+ integer_t const n, MatrixAP& ap, typename traits::matrix_traits<
+ MatrixAP >::value_type const vl, typename traits::matrix_traits<
+ MatrixAP >::value_type const vu, integer_t const il,
+ integer_t const iu, typename traits::matrix_traits<
+ MatrixAP >::value_type const abstol, integer_t& m, VectorW& w,
+ MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpevx_impl< value_type >::compute( jobz, range, n, ap, vl, vu, il,
+ iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -56,6 +58,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -122,7 +126,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t hpgv( integer_t const itype, char const jobz,
         integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpgv_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
@@ -130,6 +134,19 @@
     return info;
 }
 
+// template function to call hpgv, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ >
+inline integer_t hpgv( integer_t const itype, char const jobz,
+ integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpgv_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -63,6 +65,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -174,7 +178,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t hpgvd( integer_t const itype, char const jobz,
         integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpgvd_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
@@ -182,6 +186,19 @@
     return info;
 }
 
+// template function to call hpgvd, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ >
+inline integer_t hpgvd( integer_t const itype, char const jobz,
+ integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpgvd_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -65,6 +67,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -157,7 +161,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAP >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpgvx_impl< value_type >::compute( itype, jobz, range, n, ap, bp, vl,
@@ -165,6 +169,23 @@
     return info;
 }
 
+// template function to call hpgvx, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t hpgvx( integer_t const itype, char const jobz,
+ char const range, integer_t const n, MatrixAP& ap, MatrixBP& bp,
+ typename traits::matrix_traits< MatrixAP >::value_type const vl,
+ typename traits::matrix_traits< MatrixAP >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAP >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpgvx_impl< value_type >::compute( itype, jobz, range, n, ap, bp, vl,
+ vu, il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -50,6 +52,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -62,6 +64,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -150,8 +154,7 @@
 inline integer_t hpsvx( char const fact, integer_t const n, MatrixAP& ap,
         MatrixAFP& afp, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixAP >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     hpsvx_impl< value_type >::compute( fact, n, ap, afp, ipiv, b, x,
@@ -159,6 +162,21 @@
     return info;
 }
 
+// template function to call hpsvx, default workspace type
+template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t hpsvx( char const fact, integer_t const n, MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixAP >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ hpsvx_impl< value_type >::compute( fact, n, ap, afp, ipiv, b, x,
+ rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LACGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -46,6 +48,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorX >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LALSD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -80,6 +82,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixB,
@@ -162,6 +165,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixB,
@@ -255,7 +259,7 @@
 inline integer_t lalsd( char const uplo, integer_t const smlsiz,
         integer_t const n, VectorD& d, VectorE& e, MatrixB& b,
         typename traits::vector_traits< VectorD >::value_type const rcond,
- integer_t& rank, Workspace work = optimal_workspace() ) {
+ integer_t& rank, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     lalsd_impl< value_type >::compute( uplo, smlsiz, n, d, e, b, rcond,
@@ -263,6 +267,19 @@
     return info;
 }
 
+// template function to call lalsd, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixB >
+inline integer_t lalsd( char const uplo, integer_t const smlsiz,
+ integer_t const n, VectorD& d, VectorE& e, MatrixB& b,
+ typename traits::vector_traits< VectorD >::value_type const rcond,
+ integer_t& rank ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ lalsd_impl< value_type >::compute( uplo, smlsiz, n, d, e, b, rcond,
+ rank, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LARGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -66,6 +68,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorX, typename VectorY, typename VectorC >
@@ -93,6 +96,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // templated specialization
     template< typename VectorX, typename VectorY, typename VectorC >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAB, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -91,6 +93,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorS,
@@ -192,6 +196,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorS,
@@ -293,7 +299,7 @@
         integer_t const kd, MatrixAB& ab, MatrixAFB& afb, char& equed,
         VectorS& s, MatrixB& b, MatrixX& x, typename traits::matrix_traits<
         MatrixAB >::value_type& rcond, VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     pbsvx_impl< value_type >::compute( fact, n, kd, ab, afb, equed, s, b,
@@ -301,6 +307,21 @@
     return info;
 }
 
+// template function to call pbsvx, default workspace type
+template< typename MatrixAB, typename MatrixAFB, typename VectorS,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t pbsvx( char const fact, integer_t const n,
+ integer_t const kd, MatrixAB& ab, MatrixAFB& afb, char& equed,
+ VectorS& s, MatrixB& b, MatrixX& x, typename traits::matrix_traits<
+ MatrixAB >::value_type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ pbsvx_impl< value_type >::compute( fact, n, kd, ab, afb, equed, s, b,
+ x, rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixA, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -89,6 +91,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorS,
@@ -192,6 +196,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorS,
@@ -294,8 +300,7 @@
 inline integer_t posvx( char const fact, MatrixA& a, MatrixAF& af,
         char& equed, VectorS& s, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     posvx_impl< value_type >::compute( fact, a, af, equed, s, b, x,
@@ -303,6 +308,21 @@
     return info;
 }
 
+// template function to call posvx, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorS,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t posvx( char const fact, MatrixA& a, MatrixAF& af,
+ char& equed, VectorS& s, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ posvx_impl< value_type >::compute( fact, a, af, equed, s, b, x,
+ rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename VectorS,
@@ -183,6 +187,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename VectorS,
@@ -280,8 +286,7 @@
 inline integer_t ppsvx( char const fact, MatrixAP& ap, VectorAFP& afp,
         char& equed, VectorS& s, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixAP >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     ppsvx_impl< value_type >::compute( fact, ap, afp, equed, s, b, x,
@@ -289,6 +294,21 @@
     return info;
 }
 
+// template function to call ppsvx, default workspace type
+template< typename MatrixAP, typename VectorAFP, typename VectorS,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t ppsvx( char const fact, MatrixAP& ap, VectorAFP& afp,
+ char& equed, VectorS& s, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixAP >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ ppsvx_impl< value_type >::compute( fact, ap, afp, equed, s, b, x,
+ rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -65,6 +67,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >
@@ -94,6 +97,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >

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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
@@ -172,6 +175,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
@@ -267,8 +271,7 @@
 inline integer_t ptsvx( char const fact, integer_t const n, VectorD& d,
         VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
         typename traits::vector_traits< VectorD >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     ptsvx_impl< value_type >::compute( fact, n, d, e, df, ef, b, x,
@@ -276,6 +279,21 @@
     return info;
 }
 
+// template function to call ptsvx, default workspace type
+template< typename VectorD, typename VectorE, typename VectorDF,
+ typename VectorEF, typename MatrixB, typename MatrixX,
+ typename VectorFERR, typename VectorBERR >
+inline integer_t ptsvx( char const fact, integer_t const n, VectorD& d,
+ VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
+ typename traits::vector_traits< VectorD >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ ptsvx_impl< value_type >::compute( fact, n, d, e, df, ef, b, x,
+ rcond, ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -52,6 +54,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
@@ -108,7 +111,7 @@
         typename Workspace >
 inline integer_t sbev( char const jobz, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbev_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
@@ -116,6 +119,17 @@
     return info;
 }
 
+// template function to call sbev, default workspace type
+template< typename MatrixAB, typename VectorW, typename MatrixZ >
+inline integer_t sbev( char const jobz, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbev_impl< value_type >::compute( jobz, n, kd, ab, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #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-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -56,6 +58,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
@@ -147,7 +150,7 @@
         typename Workspace >
 inline integer_t sbevd( char const jobz, integer_t const n,
         integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z,
- integer_t const liwork, Workspace work = optimal_workspace() ) {
+ integer_t const liwork, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbevd_impl< value_type >::compute( jobz, n, kd, ab, w, z, liwork,
@@ -155,6 +158,18 @@
     return info;
 }
 
+// template function to call sbevd, default workspace type
+template< typename MatrixAB, typename VectorW, typename MatrixZ >
+inline integer_t sbevd( char const jobz, integer_t const n,
+ integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z,
+ integer_t const liwork ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbevd_impl< value_type >::compute( jobz, n, kd, ab, w, z, liwork,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -62,6 +64,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixQ, typename VectorW,
@@ -151,7 +154,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAB >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbevx_impl< value_type >::compute( jobz, range, n, kd, ab, q, vl, vu,
@@ -159,6 +162,23 @@
     return info;
 }
 
+// template function to call sbevx, default workspace type
+template< typename MatrixAB, typename MatrixQ, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t sbevx( char const jobz, char const range,
+ integer_t const n, integer_t const kd, MatrixAB& ab, MatrixQ& q,
+ typename traits::matrix_traits< MatrixAB >::value_type const vl,
+ typename traits::matrix_traits< MatrixAB >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAB >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbevx_impl< value_type >::compute( jobz, range, n, kd, ab, q, vl, vu,
+ il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -54,6 +56,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename VectorW,
@@ -121,7 +125,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t sbgv( char const jobz, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbgv_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
@@ -129,6 +133,19 @@
     return info;
 }
 
+// template function to call sbgv, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename VectorW,
+ typename MatrixZ >
+inline integer_t sbgv( char const jobz, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbgv_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -58,6 +60,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename VectorW,
@@ -160,7 +164,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t sbgvd( char const jobz, integer_t const n,
         integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbgvd_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
@@ -168,6 +172,19 @@
     return info;
 }
 
+// template function to call sbgvd, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename VectorW,
+ typename MatrixZ >
+inline integer_t sbgvd( char const jobz, integer_t const n,
+ integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbgvd_impl< value_type >::compute( jobz, n, ka, kb, ab, bb, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -64,6 +66,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixQ,
@@ -161,7 +165,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAB >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
     sbgvx_impl< value_type >::compute( jobz, range, n, ka, kb, ab, bb, q,
@@ -169,6 +173,25 @@
     return info;
 }
 
+// template function to call sbgvx, default workspace type
+template< typename MatrixAB, typename MatrixBB, typename MatrixQ,
+ typename VectorW, typename MatrixZ, typename VectorIFAIL >
+inline integer_t sbgvx( char const jobz, char const range,
+ integer_t const n, integer_t const ka, integer_t const kb,
+ MatrixAB& ab, MatrixBB& bb, MatrixQ& q,
+ typename traits::matrix_traits< MatrixAB >::value_type const vl,
+ typename traits::matrix_traits< MatrixAB >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAB >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
+ integer_t info(0);
+ sbgvx_impl< value_type >::compute( jobz, range, n, ka, kb, ab, bb, q,
+ vl, vu, il, iu, abstol, m, w, z, ifail, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SGESV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -47,6 +49,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
@@ -120,13 +124,25 @@
 template< typename MatrixA, typename VectorIPIV, typename MatrixB,
         typename MatrixX, typename Workspace >
 inline integer_t sgesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
- MatrixX& x, integer_t& iter, Workspace work = optimal_workspace() ) {
+ MatrixX& x, integer_t& iter, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sgesv_impl< value_type >::compute( a, ipiv, b, x, iter, info, work );
     return info;
 }
 
+// template function to call sgesv, default workspace type
+template< typename MatrixA, typename VectorIPIV, typename MatrixB,
+ typename MatrixX >
+inline integer_t sgesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
+ MatrixX& x, integer_t& iter ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sgesv_impl< value_type >::compute( a, ipiv, b, x, iter, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -50,6 +52,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -100,13 +103,24 @@
 template< typename MatrixAP, typename VectorW, typename MatrixZ,
         typename Workspace >
 inline integer_t spev( char const jobz, integer_t const n, MatrixAP& ap,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spev_impl< value_type >::compute( jobz, n, ap, w, z, info, work );
     return info;
 }
 
+// template function to call spev, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ >
+inline integer_t spev( char const jobz, integer_t const n, MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spev_impl< value_type >::compute( jobz, n, ap, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -136,13 +139,24 @@
 template< typename MatrixAP, typename VectorW, typename MatrixZ,
         typename Workspace >
 inline integer_t spevd( char const jobz, integer_t const n, MatrixAP& ap,
- VectorW& w, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorW& w, MatrixZ& z, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spevd_impl< value_type >::compute( jobz, n, ap, w, z, info, work );
     return info;
 }
 
+// template function to call spevd, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ >
+inline integer_t spevd( char const jobz, integer_t const n, MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spevd_impl< value_type >::compute( jobz, n, ap, w, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -58,6 +60,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorW, typename MatrixZ,
@@ -136,8 +139,7 @@
         MatrixAP >::value_type const vu, integer_t const il,
         integer_t const iu, typename traits::matrix_traits<
         MatrixAP >::value_type const abstol, integer_t& m, VectorW& w,
- MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spevx_impl< value_type >::compute( jobz, range, n, ap, vl, vu, il,
@@ -145,6 +147,23 @@
     return info;
 }
 
+// template function to call spevx, default workspace type
+template< typename MatrixAP, typename VectorW, typename MatrixZ,
+ typename VectorIFAIL >
+inline integer_t spevx( char const jobz, char const range,
+ integer_t const n, MatrixAP& ap, typename traits::matrix_traits<
+ MatrixAP >::value_type const vl, typename traits::matrix_traits<
+ MatrixAP >::value_type const vu, integer_t const il,
+ integer_t const iu, typename traits::matrix_traits<
+ MatrixAP >::value_type const abstol, integer_t& m, VectorW& w,
+ MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spevx_impl< value_type >::compute( jobz, range, n, ap, vl, vu, il,
+ iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -52,6 +54,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -111,7 +115,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t spgv( integer_t const itype, char const jobz,
         integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spgv_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
@@ -119,6 +123,19 @@
     return info;
 }
 
+// template function to call spgv, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ >
+inline integer_t spgv( integer_t const itype, char const jobz,
+ integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spgv_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -151,7 +155,7 @@
         typename MatrixZ, typename Workspace >
 inline integer_t spgvd( integer_t const itype, char const jobz,
         integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spgvd_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
@@ -159,6 +163,19 @@
     return info;
 }
 
+// template function to call spgvd, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ >
+inline integer_t spgvd( integer_t const itype, char const jobz,
+ integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spgvd_impl< value_type >::compute( itype, jobz, n, ap, bp, w, z,
+ info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -58,6 +60,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
@@ -145,7 +149,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixAP >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spgvx_impl< value_type >::compute( itype, jobz, range, n, ap, bp, vl,
@@ -153,6 +157,23 @@
     return info;
 }
 
+// template function to call spgvx, default workspace type
+template< typename MatrixAP, typename MatrixBP, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t spgvx( integer_t const itype, char const jobz,
+ char const range, integer_t const n, MatrixAP& ap, MatrixBP& bp,
+ typename traits::matrix_traits< MatrixAP >::value_type const vl,
+ typename traits::matrix_traits< MatrixAP >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixAP >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spgvx_impl< value_type >::compute( itype, jobz, range, n, ap, bp, vl,
+ vu, il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
@@ -60,6 +62,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
@@ -85,6 +87,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -178,6 +182,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
@@ -270,8 +276,7 @@
 inline integer_t spsvx( char const fact, MatrixAP& ap, MatrixAFP& afp,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixAP >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
     spsvx_impl< value_type >::compute( fact, ap, afp, ipiv, b, x, rcond,
@@ -279,6 +284,21 @@
     return info;
 }
 
+// template function to call spsvx, default workspace type
+template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t spsvx( char const fact, MatrixAP& ap, MatrixAFP& afp,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixAP >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
+ integer_t info(0);
+ spsvx_impl< value_type >::compute( fact, ap, afp, ipiv, b, x, rcond,
+ ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -49,6 +51,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -98,13 +101,24 @@
 template< typename VectorD, typename VectorE, typename MatrixZ,
         typename Workspace >
 inline integer_t stev( char const jobz, integer_t const n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixZ& z, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stev_impl< value_type >::compute( jobz, n, d, e, z, info, work );
     return info;
 }
 
+// template function to call stev, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixZ >
+inline integer_t stev( char const jobz, integer_t const n, VectorD& d,
+ VectorE& e, MatrixZ& z ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stev_impl< value_type >::compute( jobz, n, d, e, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -54,6 +56,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
@@ -130,13 +133,24 @@
 template< typename VectorD, typename VectorE, typename MatrixZ,
         typename Workspace >
 inline integer_t stevd( char const jobz, integer_t const n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work = optimal_workspace() ) {
+ VectorE& e, MatrixZ& z, Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stevd_impl< value_type >::compute( jobz, n, d, e, z, info, work );
     return info;
 }
 
+// template function to call stevd, default workspace type
+template< typename VectorD, typename VectorE, typename MatrixZ >
+inline integer_t stevd( char const jobz, integer_t const n, VectorD& d,
+ VectorE& e, MatrixZ& z ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stevd_impl< value_type >::compute( jobz, n, d, e, z, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -59,6 +61,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -155,7 +158,7 @@
         integer_t const il, integer_t const iu,
         typename traits::vector_traits< VectorD >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stevr_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
@@ -163,6 +166,23 @@
     return info;
 }
 
+// template function to call stevr, default workspace type
+template< typename VectorD, typename VectorE, typename VectorW,
+ typename MatrixZ, typename VectorISUPPZ >
+inline integer_t stevr( char const jobz, char const range,
+ integer_t const n, VectorD& d, VectorE& e,
+ typename traits::vector_traits< VectorD >::value_type const vl,
+ typename traits::vector_traits< VectorD >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::vector_traits< VectorD >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stevr_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
+ iu, abstol, m, w, z, isuppz, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/traits.hpp>
@@ -58,6 +60,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< > valid_keywords;
 
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
@@ -142,7 +145,7 @@
         integer_t const il, integer_t const iu,
         typename traits::vector_traits< VectorD >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
     stevx_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
@@ -150,6 +153,23 @@
     return info;
 }
 
+// template function to call stevx, default workspace type
+template< typename VectorD, typename VectorE, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t stevx( char const jobz, char const range,
+ integer_t const n, VectorD& d, VectorE& e,
+ typename traits::vector_traits< VectorD >::value_type const vl,
+ typename traits::vector_traits< VectorD >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::vector_traits< VectorD >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::vector_traits< VectorD >::value_type value_type;
+ integer_t info(0);
+ stevx_impl< value_type >::compute( jobz, range, n, d, e, vl, vu, il,
+ iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -51,6 +53,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename WORK >
@@ -106,13 +109,23 @@
 // template function to call syev
 template< typename MatrixA, typename VectorW, typename Workspace >
 inline integer_t syev( char const jobz, MatrixA& a, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     syev_impl< value_type >::compute( jobz, a, w, info, work );
     return info;
 }
 
+// template function to call syev, default workspace type
+template< typename MatrixA, typename VectorW >
+inline integer_t syev( char const jobz, MatrixA& a, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ syev_impl< value_type >::compute( jobz, a, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename WORK,
@@ -133,13 +136,23 @@
 // template function to call syevd
 template< typename MatrixA, typename VectorW, typename Workspace >
 inline integer_t syevd( char const jobz, MatrixA& a, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     syevd_impl< value_type >::compute( jobz, a, w, info, work );
     return info;
 }
 
+// template function to call syevd, default workspace type
+template< typename MatrixA, typename VectorW >
+inline integer_t syevd( char const jobz, MatrixA& a, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ syevd_impl< value_type >::compute( jobz, a, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVR_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -63,6 +65,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixZ,
@@ -161,7 +164,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     syevr_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
@@ -169,6 +172,22 @@
     return info;
 }
 
+// template function to call syevr, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixZ,
+ typename VectorISUPPZ >
+inline integer_t syevr( char const jobz, char const range, MatrixA& a,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ syevr_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
+ abstol, m, w, z, isuppz, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -60,6 +62,7 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixZ,
@@ -161,7 +164,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     syevx_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
@@ -169,6 +172,22 @@
     return info;
 }
 
+// template function to call syevx, default workspace type
+template< typename MatrixA, typename VectorW, typename MatrixZ,
+ typename VectorIFAIL >
+inline integer_t syevx( char const jobz, char const range, MatrixA& a,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ syevx_impl< value_type >::compute( jobz, range, a, vl, vu, il, iu,
+ abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -55,6 +57,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -119,7 +123,7 @@
         typename Workspace >
 inline integer_t sygv( integer_t const itype, char const jobz,
         integer_t const n, MatrixA& a, MatrixB& b, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sygv_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
@@ -127,6 +131,17 @@
     return info;
 }
 
+// template function to call sygv, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW >
+inline integer_t sygv( integer_t const itype, char const jobz,
+ integer_t const n, MatrixA& a, MatrixB& b, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sygv_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVD_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -57,6 +59,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -147,7 +151,7 @@
         typename Workspace >
 inline integer_t sygvd( integer_t const itype, char const jobz,
         integer_t const n, MatrixA& a, MatrixB& b, VectorW& w,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sygvd_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
@@ -155,6 +159,17 @@
     return info;
 }
 
+// template function to call sygvd, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW >
+inline integer_t sygvd( integer_t const itype, char const jobz,
+ integer_t const n, MatrixA& a, MatrixB& b, VectorW& w ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sygvd_impl< value_type >::compute( itype, jobz, n, a, b, w, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -64,6 +66,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorW,
@@ -166,7 +170,7 @@
         integer_t const il, integer_t const iu,
         typename traits::matrix_traits< MatrixA >::value_type const abstol,
         integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sygvx_impl< value_type >::compute( itype, jobz, range, n, a, b, vl,
@@ -174,6 +178,23 @@
     return info;
 }
 
+// template function to call sygvx, default workspace type
+template< typename MatrixA, typename MatrixB, typename VectorW,
+ typename MatrixZ, typename VectorIFAIL >
+inline integer_t sygvx( integer_t const itype, char const jobz,
+ char const range, integer_t const n, MatrixA& a, MatrixB& b,
+ typename traits::matrix_traits< MatrixA >::value_type const vl,
+ typename traits::matrix_traits< MatrixA >::value_type const vu,
+ integer_t const il, integer_t const iu,
+ typename traits::matrix_traits< MatrixA >::value_type const abstol,
+ integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sygvx_impl< value_type >::compute( itype, jobz, range, n, a, b, vl,
+ vu, il, iu, abstol, m, w, z, ifail, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSV_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -78,6 +80,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
@@ -140,6 +144,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
@@ -201,13 +207,23 @@
 template< typename MatrixA, typename VectorIPIV, typename MatrixB,
         typename Workspace >
 inline integer_t sysv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
- Workspace work = optimal_workspace() ) {
+ Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sysv_impl< value_type >::compute( a, ipiv, b, info, work );
     return info;
 }
 
+// template function to call sysv, default workspace type
+template< typename MatrixA, typename VectorIPIV, typename MatrixB >
+inline integer_t sysv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sysv_impl< value_type >::compute( a, ipiv, b, info,
+ optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -15,7 +15,9 @@
 #define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSVX_HPP
 
 #include <boost/assert.hpp>
+#include <boost/mpl/vector.hpp>
 #include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/keywords.hpp>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
 #include <boost/numeric/bindings/traits/detail/utils.hpp>
@@ -92,6 +94,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -205,6 +209,8 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
+ typedef typename mpl::vector< keywords::tag::A, keywords::tag::pivot,
+ keywords::tag::B > valid_keywords;
 
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
@@ -317,8 +323,7 @@
 inline integer_t sysvx( char const fact, MatrixA& a, MatrixAF& af,
         VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
         typename traits::matrix_traits< MatrixA >::value_type& rcond,
- VectorFERR& ferr, VectorBERR& berr,
- Workspace work = optimal_workspace() ) {
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
     sysvx_impl< value_type >::compute( fact, a, af, ipiv, b, x, rcond,
@@ -326,6 +331,21 @@
     return info;
 }
 
+// template function to call sysvx, default workspace type
+template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
+ typename MatrixB, typename MatrixX, typename VectorFERR,
+ typename VectorBERR >
+inline integer_t sysvx( char const fact, MatrixA& a, MatrixAF& af,
+ VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ typename traits::matrix_traits< MatrixA >::value_type& rcond,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
+ integer_t info(0);
+ sysvx_impl< value_type >::compute( fact, a, af, ipiv, b, x, rcond,
+ ferr, berr, info, optimal_workspace() );
+ return info;
+}
+
 }}}} // namespace boost::numeric::bindings::lapack
 
 #endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/keywords.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/keywords.hpp 2009-03-19 15:51:01 EDT (Thu, 19 Mar 2009)
@@ -0,0 +1,30 @@
+//
+// Copyright (c) 2009 Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_KEYWORDS_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_KEYWORDS_HPP
+
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+namespace keywords {
+
+BOOST_PARAMETER_NAME( A )
+BOOST_PARAMETER_NAME( B )
+BOOST_PARAMETER_NAME( pivot )
+BOOST_PARAMETER_NAME( workspace )
+
+}
+
+}}}} // namespace boost::numeric::bindings::lapack
+
+#endif


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk