Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r51869 - in sandbox/numeric_bindings/boost/numeric/bindings/lapack: computational driver
From: rutger_at_[hidden]
Date: 2009-03-20 12:43:39


Author: rutger
Date: 2009-03-20 12:43:05 EDT (Fri, 20 Mar 2009)
New Revision: 51869
URL: http://svn.boost.org/trac/boost/changeset/51869

Log:
Updated computational and driver routines in lapack

Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp | 24 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp | 67 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 13 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp | 34 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 25 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp | 42 ++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp | 65 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 20 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 35 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 16 +++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 40 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp | 48 ++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp | 38 +++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 38 +++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 24 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 40 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 37 ++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 10 +---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp | 14 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp | 31 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 20 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp | 34 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp | 34 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp | 92 ++++++++++++++++++---------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp | 40 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp | 34 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp | 34 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp | 85 ++++++++++++++++--------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp | 78 ++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp | 40 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp | 88 +++++++++++++++++--------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp | 14 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 18 +++----
   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 | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 23 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp | 25 ++++++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 23 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 23 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp | 9 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp | 30 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 40 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 36 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 28 ++++++++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 34 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 18 +++----
   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 | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 23 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 23 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp | 15 +++--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 32 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp | 22 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp | 18 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp | 19 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp | 44 +++++++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 32 ++++++-------
   229 files changed, 2461 insertions(+), 3027 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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,13 +54,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixU,
             typename MatrixVT, typename VectorQ, typename VectorIQ,
             typename WORK, typename IWORK >
- static void compute( char const uplo, char const compq, integer_t const n,
+ static void invoke( char const uplo, char const compq, integer_t const n,
             VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q,
             VectorIQ& iq, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -98,23 +96,23 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixU,
             typename MatrixVT, typename VectorQ, typename VectorIQ >
- static void compute( char const uplo, char const compq, integer_t const n,
+ static void invoke( char const uplo, char const compq, integer_t const n,
             VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q,
             VectorIQ& iq, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( compq,
                 n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( uplo, compq, n, d, e, u, vt, q, iq, info,
- workspace( tmp_work, tmp_iwork ) );
+ invoke( uplo, compq, n, d, e, u, vt, q, iq, info, workspace( tmp_work,
+ tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixU,
             typename MatrixVT, typename VectorQ, typename VectorIQ >
- static void compute( char const uplo, char const compq, integer_t const n,
+ static void invoke( char const uplo, char const compq, integer_t const n,
             VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q,
             VectorIQ& iq, integer_t& info, optimal_workspace work ) {
- compute( uplo, compq, n, d, e, u, vt, q, iq, info,
+ invoke( uplo, compq, n, d, e, u, vt, q, iq, info,
                 minimal_workspace() );
     }
 
@@ -141,8 +139,8 @@
         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,
- iq, info, work );
+ bdsdc_impl< value_type >::invoke( uplo, compq, n, d, e, u, vt, q, iq,
+ info, work );
     return info;
 }
 
@@ -154,8 +152,8 @@
         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() );
+ bdsdc_impl< value_type >::invoke( uplo, compq, n, d, e, u, vt, q, iq,
+ info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -83,12 +81,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC, typename WORK >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -125,22 +123,22 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n,
                 traits::matrix_num_columns(vt), traits::matrix_num_rows(u),
                 traits::matrix_num_columns(c) ) );
- compute( uplo, n, d, e, vt, u, c, info, workspace( tmp_work ) );
+ invoke( uplo, n, d, e, vt, u, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, n, d, e, vt, u, c, info, minimal_workspace() );
+ invoke( uplo, n, d, e, vt, u, c, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n, integer_t const ncvt,
@@ -158,12 +156,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC, typename RWORK >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             detail::workspace1< RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -197,22 +195,22 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n,
                 traits::matrix_num_columns(vt), traits::matrix_num_rows(u),
                 traits::matrix_num_columns(c) ) );
- compute( uplo, n, d, e, vt, u, c, info, workspace( tmp_rwork ) );
+ invoke( uplo, n, d, e, vt, u, c, info, workspace( tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixVT,
             typename MatrixU, typename MatrixC >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, n, d, e, vt, u, c, info, minimal_workspace() );
+ invoke( uplo, n, d, e, vt, u, c, info, minimal_workspace() );
     }
 
     static integer_t min_size_rwork( integer_t const n, integer_t const ncvt,
@@ -232,7 +230,7 @@
         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,
+ bdsqr_impl< value_type >::invoke( uplo, n, d, e, vt, u, c, info,
             work );
     return info;
 }
@@ -244,7 +242,7 @@
         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,
+ bdsqr_impl< value_type >::invoke( uplo, n, d, e, vt, u, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,16 +85,16 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC,
             typename WORK >
- static void compute( 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, integer_t& info, detail::workspace1< WORK > work ) {
+ static void invoke( 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, integer_t& info,
+ detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorD >::value_type >::value) );
@@ -136,23 +134,23 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC >
- static void compute( 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, integer_t& info, minimal_workspace work ) {
+ static void invoke( 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, integer_t& info,
+ minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( m, n ) );
- compute( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
+ invoke( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC >
- static void compute( 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, integer_t& info, optimal_workspace work ) {
- compute( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
+ static void invoke( 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, integer_t& info,
+ optimal_workspace work ) {
+ invoke( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
                 minimal_workspace() );
     }
 
@@ -167,17 +165,16 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC,
             typename WORK, typename RWORK >
- static void compute( 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, integer_t& info, detail::workspace2< WORK,
- RWORK > work ) {
+ static void invoke( 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, integer_t& info,
+ detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
@@ -217,24 +214,24 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC >
- static void compute( 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, integer_t& info, minimal_workspace work ) {
+ static void invoke( 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, integer_t& info,
+ minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( m, n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( m, n ) );
- compute( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
+ invoke( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename MatrixPT, typename MatrixC >
- static void compute( 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, integer_t& info, optimal_workspace work ) {
- compute( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
+ static void invoke( 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, integer_t& info,
+ optimal_workspace work ) {
+ invoke( vect, m, n, kl, ku, ab, d, e, q, pt, c, info,
                 minimal_workspace() );
     }
 
@@ -258,7 +255,7 @@
         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,
+ gbbrd_impl< value_type >::invoke( vect, m, n, kl, ku, ab, d, e, q,
             pt, c, info, work );
     return info;
 }
@@ -272,7 +269,7 @@
         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,
+ gbbrd_impl< value_type >::invoke( vect, m, n, kl, ku, ab, d, e, q,
             pt, c, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -79,13 +77,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
             typename IWORK >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
@@ -108,23 +105,23 @@
 
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorIPIV >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
+ invoke( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorIPIV >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, optimal_workspace work ) {
- compute( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
+ invoke( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
                 minimal_workspace() );
     }
 
@@ -143,13 +140,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
             typename RWORK >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
@@ -172,23 +168,23 @@
 
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorIPIV >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
+ invoke( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorIPIV >
- static void compute( char const norm, integer_t const n,
+ static void invoke( char const norm, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, optimal_workspace work ) {
- compute( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
+ invoke( norm, n, kl, ku, ab, ipiv, anorm, rcond, info,
                 minimal_workspace() );
     }
 
@@ -211,7 +207,7 @@
         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,
+ gbcon_impl< value_type >::invoke( norm, n, kl, ku, ab, ipiv, anorm,
             rcond, info, work );
     return info;
 }
@@ -225,7 +221,7 @@
         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,
+ gbcon_impl< value_type >::invoke( norm, n, kl, ku, ab, ipiv, anorm,
             rcond, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorR, typename VectorC >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab, VectorR& r,
             VectorC& c, real_type& rowcnd, real_type& colcnd, real_type& amax,
             integer_t& info ) {
@@ -106,11 +104,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorR, typename VectorC >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab, VectorR& r,
             VectorC& c, real_type& rowcnd, real_type& colcnd, real_type& amax,
             integer_t& info ) {
@@ -139,7 +137,7 @@
         MatrixAB >::value_type& amax ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- gbequ_impl< value_type >::compute( m, n, kl, ku, ab, r, c, rowcnd,
+ gbequ_impl< value_type >::invoke( m, n, kl, ku, ab, r, c, rowcnd,
             colcnd, amax, info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -91,14 +89,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename IWORK >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
@@ -149,14 +146,14 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
+ invoke( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -164,12 +161,12 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
+ invoke( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -188,14 +185,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
@@ -243,14 +239,14 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
+ invoke( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -258,12 +254,12 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, integer_t const n,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
+ invoke( trans, n, kl, ku, ab, afb, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -287,8 +283,8 @@
         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,
- b, x, ferr, berr, info, work );
+ gbrfs_impl< value_type >::invoke( trans, n, kl, ku, ab, afb, ipiv, b,
+ x, ferr, berr, info, work );
     return info;
 }
 
@@ -302,8 +298,8 @@
         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() );
+ gbrfs_impl< value_type >::invoke( trans, n, kl, ku, ab, afb, ipiv, b,
+ x, ferr, berr, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,12 +60,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, integer_t& info ) {
         BOOST_ASSERT( m >= 0 );
@@ -90,7 +87,7 @@
         VectorIPIV& ipiv ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- gbtrf_impl< value_type >::compute( m, n, kl, ku, ab, ipiv, info );
+ gbtrf_impl< value_type >::invoke( m, n, kl, ku, ab, ipiv, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -68,12 +66,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
- static void compute( char const trans, integer_t const n,
+ static void invoke( char const trans, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -102,7 +99,7 @@
         VectorIPIV& ipiv, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- gbtrs_impl< value_type >::compute( trans, n, kl, ku, ab, ipiv, b,
+ gbtrs_impl< value_type >::invoke( trans, n, kl, ku, ab, ipiv, b,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorSCALE, typename MatrixV >
- static void compute( char const job, char const side, integer_t const ilo,
+ static void invoke( char const job, char const side, integer_t const ilo,
             integer_t const ihi, VectorSCALE& scale, MatrixV& v,
             integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -106,11 +104,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorSCALE, typename MatrixV >
- static void compute( char const job, char const side, integer_t const ilo,
+ static void invoke( char const job, char const side, integer_t const ilo,
             integer_t const ihi, VectorSCALE& scale, MatrixV& v,
             integer_t& info ) {
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
@@ -137,7 +135,7 @@
     typedef typename traits::vector_traits<
             VectorSCALE >::value_type value_type;
     integer_t info(0);
- gebak_impl< value_type >::compute( job, side, ilo, ihi, scale, v,
+ gebak_impl< value_type >::invoke( job, side, ilo, ihi, scale, v,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -69,11 +67,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorSCALE >
- static void compute( char const job, MatrixA& a, integer_t& ilo,
+ static void invoke( char const job, MatrixA& a, integer_t& ilo,
             integer_t& ihi, VectorSCALE& scale, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -94,11 +92,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorSCALE >
- static void compute( char const job, MatrixA& a, integer_t& ilo,
+ static void invoke( char const job, MatrixA& a, integer_t& ilo,
             integer_t& ihi, VectorSCALE& scale, integer_t& info ) {
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -117,7 +115,7 @@
         integer_t& ihi, VectorSCALE& scale ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- gebal_impl< value_type >::compute( job, a, ilo, ihi, scale, info );
+ gebal_impl< value_type >::invoke( job, a, ilo, ihi, scale, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -79,12 +77,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP, typename WORK >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -127,17 +125,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a), traits::matrix_num_columns(a) ) );
- compute( a, d, e, tauq, taup, info, workspace( tmp_work ) );
+ invoke( a, d, e, tauq, taup, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::gebrd( traits::matrix_num_rows(a),
@@ -147,7 +145,7 @@
                 traits::vector_storage(taup), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, d, e, tauq, taup, info, workspace( tmp_work ) );
+ invoke( a, d, e, tauq, taup, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m, integer_t const n ) {
@@ -161,12 +159,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP, typename WORK >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -206,17 +204,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a), traits::matrix_num_columns(a) ) );
- compute( a, d, e, tauq, taup, info, workspace( tmp_work ) );
+ invoke( a, d, e, tauq, taup, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::gebrd( traits::matrix_num_rows(a),
@@ -226,7 +224,7 @@
                 traits::vector_storage(taup), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, d, e, tauq, taup, info, workspace( tmp_work ) );
+ invoke( a, d, e, tauq, taup, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m, integer_t const n ) {
@@ -242,7 +240,7 @@
         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 );
+ gebrd_impl< value_type >::invoke( a, d, e, tauq, taup, info, work );
     return info;
 }
 
@@ -253,7 +251,7 @@
         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,
+ gebrd_impl< value_type >::invoke( a, d, e, tauq, taup, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -99,21 +97,21 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( norm, a, anorm, rcond, info, workspace( tmp_work,
+ invoke( norm, a, anorm, rcond, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( norm, a, anorm, rcond, info, minimal_workspace() );
+ invoke( norm, a, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -131,11 +129,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -155,21 +153,21 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( norm, a, anorm, rcond, info, workspace( tmp_work,
+ invoke( norm, a, anorm, rcond, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, MatrixA& a, real_type const anorm,
+ static void invoke( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( norm, a, anorm, rcond, info, minimal_workspace() );
+ invoke( norm, a, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -190,8 +188,7 @@
         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,
- work );
+ gecon_impl< value_type >::invoke( norm, a, anorm, rcond, info, work );
     return info;
 }
 
@@ -202,7 +199,7 @@
         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,
+ gecon_impl< value_type >::invoke( norm, a, anorm, rcond, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -69,13 +67,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorR, typename VectorC >
- static void compute( MatrixA& a, VectorR& r, VectorC& c,
- real_type& rowcnd, real_type& colcnd, real_type& amax,
- integer_t& info ) {
+ static void invoke( MatrixA& a, VectorR& r, VectorC& c, real_type& rowcnd,
+ real_type& colcnd, real_type& amax, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorR >::value_type >::value) );
@@ -99,13 +96,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorR, typename VectorC >
- static void compute( MatrixA& a, VectorR& r, VectorC& c,
- real_type& rowcnd, real_type& colcnd, real_type& amax,
- integer_t& info ) {
+ static void invoke( MatrixA& a, VectorR& r, VectorC& c, real_type& rowcnd,
+ real_type& colcnd, real_type& amax, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorR >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
@@ -129,7 +125,7 @@
         typename traits::matrix_traits< MatrixA >::value_type& amax ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- geequ_impl< value_type >::compute( a, r, c, rowcnd, colcnd, amax,
+ geequ_impl< value_type >::invoke( a, r, c, rowcnd, colcnd, amax,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -76,11 +74,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -102,16 +100,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
@@ -119,7 +117,7 @@
                 traits::vector_storage(tau), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -133,11 +131,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -159,16 +157,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const ilo, integer_t const ihi, MatrixA& a,
+ static void invoke( integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
@@ -176,7 +174,7 @@
                 traits::vector_storage(tau), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -191,7 +189,7 @@
         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 );
+ gehrd_impl< value_type >::invoke( ilo, ihi, a, tau, info, work );
     return info;
 }
 
@@ -201,7 +199,7 @@
         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,
+ gehrd_impl< value_type >::invoke( ilo, ihi, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,11 +72,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -101,16 +99,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a) ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::gelqf( traits::matrix_num_rows(a),
@@ -119,7 +117,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -133,11 +131,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -160,16 +158,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a) ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::gelqf( traits::matrix_num_rows(a),
@@ -178,7 +176,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -192,7 +190,7 @@
 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 );
+ gelqf_impl< value_type >::invoke( a, tau, info, work );
     return info;
 }
 
@@ -201,8 +199,7 @@
 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() );
+ gelqf_impl< value_type >::invoke( a, tau, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,11 +72,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -101,16 +99,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::geqlf( traits::matrix_num_rows(a),
@@ -119,7 +117,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -133,11 +131,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -160,16 +158,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::geqlf( traits::matrix_num_rows(a),
@@ -178,7 +176,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -192,7 +190,7 @@
 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 );
+ geqlf_impl< value_type >::invoke( a, tau, info, work );
     return info;
 }
 
@@ -201,8 +199,7 @@
 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() );
+ geqlf_impl< value_type >::invoke( a, tau, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -76,12 +74,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU,
             typename WORK >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -105,16 +103,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( a, jpvt, tau, info, workspace( tmp_work ) );
+ invoke( a, jpvt, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::geqp3( traits::matrix_num_rows(a),
@@ -123,7 +121,7 @@
                 traits::vector_storage(tau), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, jpvt, tau, info, workspace( tmp_work ) );
+ invoke( a, jpvt, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -137,12 +135,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU,
             typename WORK, typename RWORK >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -169,18 +167,18 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, jpvt, tau, info, workspace( tmp_work, tmp_rwork ) );
+ invoke( a, jpvt, tau, info, workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
- static void compute( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
@@ -192,7 +190,7 @@
                 traits::vector_storage(tmp_rwork), info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, jpvt, tau, info, workspace( tmp_work, tmp_rwork ) );
+ invoke( a, jpvt, tau, info, workspace( tmp_work, tmp_rwork ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -212,7 +210,7 @@
         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 );
+ geqp3_impl< value_type >::invoke( a, jpvt, tau, info, work );
     return info;
 }
 
@@ -221,7 +219,7 @@
 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,
+ geqp3_impl< value_type >::invoke( a, jpvt, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,11 +72,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -101,16 +99,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::geqrf( traits::matrix_num_rows(a),
@@ -119,7 +117,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -133,11 +131,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -160,16 +158,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::geqrf( traits::matrix_num_rows(a),
@@ -178,7 +176,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -192,7 +190,7 @@
 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 );
+ geqrf_impl< value_type >::invoke( a, tau, info, work );
     return info;
 }
 
@@ -201,8 +199,7 @@
 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() );
+ geqrf_impl< value_type >::invoke( a, tau, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename IWORK >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -147,14 +144,14 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( trans, a, af, ipiv, b, x, ferr, berr, info,
+ invoke( trans, a, af, ipiv, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -162,10 +159,10 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( trans, a, af, ipiv, b, x, ferr, berr, info,
+ invoke( trans, a, af, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -184,14 +181,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -241,14 +237,14 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( trans, a, af, ipiv, b, x, ferr, berr, info,
+ invoke( trans, a, af, ipiv, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -256,10 +252,10 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( char const trans, MatrixA& a, MatrixAF& af,
+ static void invoke( char const trans, MatrixA& a, MatrixAF& af,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( trans, a, af, ipiv, b, x, ferr, berr, info,
+ invoke( trans, a, af, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -282,7 +278,7 @@
         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,
+ gerfs_impl< value_type >::invoke( trans, a, af, ipiv, b, x, ferr,
             berr, info, work );
     return info;
 }
@@ -296,7 +292,7 @@
         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,
+ gerfs_impl< value_type >::invoke( trans, a, af, ipiv, b, x, ferr,
             berr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,11 +72,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -101,16 +99,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::gerqf( traits::matrix_num_rows(a),
@@ -119,7 +117,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -133,11 +131,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -160,16 +158,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::gerqf( traits::matrix_num_rows(a),
@@ -178,7 +176,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -192,7 +190,7 @@
 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 );
+ gerqf_impl< value_type >::invoke( a, tau, info, work );
     return info;
 }
 
@@ -201,8 +199,7 @@
 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() );
+ gerqf_impl< value_type >::invoke( a, tau, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info ) {
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
         BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
@@ -84,7 +81,7 @@
 inline integer_t getrf( MatrixA& a, VectorIPIV& ipiv ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- getrf_impl< value_type >::compute( a, ipiv, info );
+ getrf_impl< value_type >::invoke( a, ipiv, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -72,12 +70,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
         BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
@@ -95,16 +92,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::getri( traits::matrix_num_columns(a),
@@ -112,7 +109,7 @@
                 traits::vector_storage(ipiv), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -126,12 +123,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
         BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
@@ -149,16 +145,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::getri( traits::matrix_num_columns(a),
@@ -166,7 +162,7 @@
                 traits::vector_storage(ipiv), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -180,7 +176,7 @@
 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 );
+ getri_impl< value_type >::invoke( a, ipiv, info, work );
     return info;
 }
 
@@ -189,7 +185,7 @@
 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,
+ getri_impl< value_type >::invoke( a, ipiv, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -65,12 +63,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >
- static void compute( char const trans, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const trans, MatrixA& a, VectorIPIV& ipiv,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -99,7 +96,7 @@
         MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- getrs_impl< value_type >::compute( trans, a, ipiv, b, info );
+ getrs_impl< value_type >::invoke( trans, a, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorLSCALE, typename VectorRSCALE, typename MatrixV >
- static void compute( char const job, char const side, integer_t const ilo,
+ static void invoke( char const job, char const side, integer_t const ilo,
             integer_t const ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
             MatrixV& v, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -112,11 +110,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorLSCALE, typename VectorRSCALE, typename MatrixV >
- static void compute( char const job, char const side, integer_t const ilo,
+ static void invoke( char const job, char const side, integer_t const ilo,
             integer_t const ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
             MatrixV& v, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -149,7 +147,7 @@
     typedef typename traits::vector_traits<
             VectorLSCALE >::value_type value_type;
     integer_t info(0);
- ggbak_impl< value_type >::compute( job, side, ilo, ihi, lscale,
+ ggbak_impl< value_type >::invoke( job, side, ilo, ihi, lscale,
             rscale, v, info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -79,13 +77,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE, typename WORK >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, detail::workspace1<
             WORK > work ) {
@@ -115,22 +112,22 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( job, n, a, b, ilo, ihi, lscale, rscale, info,
+ invoke( job, n, a, b, ilo, ihi, lscale, rscale, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, optimal_workspace work ) {
- compute( job, n, a, b, ilo, ihi, lscale, rscale, info,
+ invoke( job, n, a, b, ilo, ihi, lscale, rscale, info,
                 minimal_workspace() );
     }
 
@@ -145,13 +142,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE, typename WORK >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, detail::workspace1<
             WORK > work ) {
@@ -178,22 +174,22 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( job, n, a, b, ilo, ihi, lscale, rscale, info,
+ invoke( job, n, a, b, ilo, ihi, lscale, rscale, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static void compute( char const job, integer_t const n, MatrixA& a,
+ static void invoke( char const job, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
             VectorRSCALE& rscale, integer_t& info, optimal_workspace work ) {
- compute( job, n, a, b, ilo, ihi, lscale, rscale, info,
+ invoke( job, n, a, b, ilo, ihi, lscale, rscale, info,
                 minimal_workspace() );
     }
 
@@ -211,7 +207,7 @@
         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,
+ ggbal_impl< value_type >::invoke( job, n, a, b, ilo, ihi, lscale,
             rscale, info, work );
     return info;
 }
@@ -224,7 +220,7 @@
         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,
+ ggbal_impl< value_type >::invoke( job, n, a, b, ilo, ihi, lscale,
             rscale, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,15 +72,14 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
- static void compute( char const compq, char const compz,
- integer_t const n, integer_t const ilo, MatrixA& a, MatrixB& b,
- MatrixQ& q, MatrixZ& z, integer_t& info ) {
+ static void invoke( char const compq, char const compz, integer_t const n,
+ integer_t const ilo, MatrixA& a, MatrixB& b, MatrixQ& q,
+ MatrixZ& z, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
@@ -115,7 +112,7 @@
         MatrixQ& q, MatrixZ& z ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- gghrd_impl< value_type >::compute( compq, compz, n, ilo, a, b, q, z,
+ gghrd_impl< value_type >::invoke( compq, compz, n, ilo, a, b, q, z,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -84,13 +82,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB, typename WORK >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -129,17 +126,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::ggqrf( traits::matrix_num_rows(b),
@@ -150,7 +147,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -164,13 +161,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB, typename WORK >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -209,17 +205,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::ggqrf( traits::matrix_num_rows(b),
@@ -230,7 +226,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -246,7 +242,7 @@
         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 );
+ ggqrf_impl< value_type >::invoke( a, taua, b, taub, info, work );
     return info;
 }
 
@@ -257,7 +253,7 @@
         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,
+ ggqrf_impl< value_type >::invoke( a, taua, b, taub, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -84,13 +82,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB, typename WORK >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -129,17 +126,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::ggrqf( traits::matrix_num_rows(a),
@@ -150,7 +147,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -164,13 +161,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB, typename WORK >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -209,17 +205,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAUA, typename MatrixB,
             typename VectorTAUB >
- static void compute( MatrixA& a, VectorTAUA& taua, MatrixB& b,
+ static void invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::ggrqf( traits::matrix_num_rows(a),
@@ -230,7 +226,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, taua, b, taub, info, workspace( tmp_work ) );
+ invoke( a, taua, b, taub, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -246,7 +242,7 @@
         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 );
+ ggrqf_impl< value_type >::invoke( a, taua, b, taub, info, work );
     return info;
 }
 
@@ -257,7 +253,7 @@
         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,
+ ggrqf_impl< value_type >::invoke( a, taua, b, taub, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -103,14 +101,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ, typename IWORK, typename TAU,
             typename WORK >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, detail::workspace3<
@@ -160,7 +157,7 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, minimal_workspace work ) {
@@ -171,18 +168,18 @@
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(b), traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b) ) );
- compute( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
+ invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
                 workspace( tmp_iwork, tmp_tau, tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
+ invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
                 minimal_workspace() );
     }
 
@@ -206,14 +203,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ, typename IWORK,
             typename RWORK, typename TAU, typename WORK >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, detail::workspace4<
@@ -266,7 +262,7 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, minimal_workspace work ) {
@@ -279,18 +275,18 @@
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(b), traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b) ) );
- compute( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
+ invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
                 workspace( tmp_iwork, tmp_rwork, tmp_tau, tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixU,
             typename MatrixV, typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             MatrixA& a, MatrixB& b, real_type const tola,
             real_type const tolb, integer_t& k, integer_t& l, MatrixU& u,
             MatrixV& v, MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
+ invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, info,
                 minimal_workspace() );
     }
 
@@ -324,8 +320,8 @@
         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,
- tolb, k, l, u, v, q, info, work );
+ ggsvp_impl< value_type >::invoke( jobu, jobv, jobq, a, b, tola, tolb,
+ k, l, u, v, q, info, work );
     return info;
 }
 
@@ -339,8 +335,8 @@
         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() );
+ ggsvp_impl< value_type >::invoke( jobu, jobv, jobq, a, b, tola, tolb,
+ k, l, u, v, q, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -96,16 +94,15 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     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,
             typename WORK, typename IWORK >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
@@ -176,14 +173,14 @@
             typename VectorDLF, typename VectorDF, typename VectorDUF,
             typename VectorDU2, typename VectorIPIV, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
+ invoke( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, info, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -192,12 +189,12 @@
             typename VectorDLF, typename VectorDF, typename VectorDUF,
             typename VectorDU2, typename VectorIPIV, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
+ invoke( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, info, minimal_workspace() );
     }
 
@@ -216,16 +213,15 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     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,
             typename WORK, typename RWORK >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
@@ -293,14 +289,14 @@
             typename VectorDLF, typename VectorDF, typename VectorDUF,
             typename VectorDU2, typename VectorIPIV, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
+ invoke( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, info, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -309,12 +305,12 @@
             typename VectorDLF, typename VectorDF, typename VectorDUF,
             typename VectorDU2, typename VectorIPIV, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
+ invoke( trans, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, info, minimal_workspace() );
     }
 
@@ -340,7 +336,7 @@
         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,
+ gtrfs_impl< value_type >::invoke( trans, n, dl, d, du, dlf, df, duf,
             du2, ipiv, b, x, ferr, berr, info, work );
     return info;
 }
@@ -356,7 +352,7 @@
         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,
+ gtrfs_impl< value_type >::invoke( trans, n, dl, d, du, dlf, df, duf,
             du2, ipiv, b, x, ferr, berr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,13 +69,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorDL, typename VectorD, typename VectorDU,
             typename VectorDU2, typename VectorIPIV, typename MatrixB >
- static void compute( char const trans, integer_t const n, VectorDL& dl,
+ static void invoke( char const trans, integer_t const n, VectorDL& dl,
             VectorD& d, VectorDU& du, VectorDU2& du2, VectorIPIV& ipiv,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -117,7 +114,7 @@
         VectorIPIV& ipiv, MatrixB& b ) {
     typedef typename traits::vector_traits< VectorDL >::value_type value_type;
     integer_t info(0);
- gttrs_impl< value_type >::compute( trans, n, dl, d, du, du2, ipiv, b,
+ gttrs_impl< value_type >::invoke( trans, n, dl, d, du, du2, ipiv, b,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -60,12 +58,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
             typename WORK, typename RWORK >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info, detail::workspace2<
             WORK, RWORK > work ) {
@@ -97,23 +95,23 @@
 
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( vect, n, ka, kb, ab, bb, x, info, workspace( tmp_work,
+ invoke( vect, n, ka, kb, ab, bb, x, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info,
             optimal_workspace work ) {
- compute( vect, n, ka, kb, ab, bb, x, info, minimal_workspace() );
+ invoke( vect, n, ka, kb, ab, bb, x, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -134,7 +132,7 @@
         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,
+ hbgst_impl< value_type >::invoke( vect, n, ka, kb, ab, bb, x, info,
             work );
     return info;
 }
@@ -146,7 +144,7 @@
         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,
+ hbgst_impl< value_type >::invoke( vect, n, ka, kb, ab, bb, x, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename WORK >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -91,20 +89,20 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
- compute( vect, n, kd, ab, d, e, q, info, workspace( tmp_work ) );
+ invoke( vect, n, kd, ab, d, e, q, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( vect, n, kd, ab, d, e, q, info, minimal_workspace() );
+ invoke( vect, n, kd, ab, d, e, q, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -121,7 +119,7 @@
         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,
+ hbtrd_impl< value_type >::invoke( vect, n, kd, ab, d, e, q, info,
             work );
     return info;
 }
@@ -134,7 +132,7 @@
         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,
+ hbtrd_impl< value_type >::invoke( vect, n, kd, ab, d, e, q, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,12 +54,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
@@ -80,20 +77,20 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work ) );
+ invoke( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -110,7 +107,7 @@
         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,
+ hecon_impl< value_type >::invoke( uplo, a, ipiv, anorm, rcond, info,
             work );
     return info;
 }
@@ -122,7 +119,7 @@
         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,
+ hecon_impl< value_type >::invoke( uplo, a, ipiv, anorm, rcond, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -52,12 +50,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB >
- static void compute( integer_t const itype, integer_t const n, MatrixA& a,
+ static void invoke( integer_t const itype, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -81,7 +78,7 @@
         MatrixA& a, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- hegst_impl< value_type >::compute( itype, n, a, b, info );
+ hegst_impl< value_type >::invoke( itype, n, a, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -64,14 +62,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -122,14 +119,14 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -137,10 +134,10 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, optimal_workspace work ) {
- compute( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -162,7 +159,7 @@
         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,
+ herfs_impl< value_type >::invoke( a, af, ipiv, b, x, ferr, berr,
             info, work );
     return info;
 }
@@ -175,7 +172,7 @@
         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,
+ herfs_impl< value_type >::invoke( a, af, ipiv, b, x, ferr, berr,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,12 +57,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
@@ -94,16 +92,16 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( ) );
- compute( a, d, e, tau, info, workspace( tmp_work ) );
+ invoke( a, d, e, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::hetrd( traits::matrix_uplo_tag(a),
@@ -113,7 +111,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, d, e, tau, info, workspace( tmp_work ) );
+ invoke( a, d, e, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( ) {
@@ -129,7 +127,7 @@
         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 );
+ hetrd_impl< value_type >::invoke( a, d, e, tau, info, work );
     return info;
 }
 
@@ -140,7 +138,7 @@
         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,
+ hetrd_impl< value_type >::invoke( a, d, e, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -54,12 +52,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -77,17 +74,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             optimal_workspace work ) {
- compute( a, ipiv, info, minimal_workspace() );
+ invoke( a, ipiv, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( ) {
@@ -101,7 +98,7 @@
 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 );
+ hetrf_impl< value_type >::invoke( a, ipiv, info, work );
     return info;
 }
 
@@ -110,7 +107,7 @@
 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,
+ hetrf_impl< value_type >::invoke( a, ipiv, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -54,12 +52,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -77,18 +74,18 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, info, workspace( tmp_work ) );
+ invoke( uplo, a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, optimal_workspace work ) {
- compute( uplo, a, ipiv, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -103,7 +100,7 @@
         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 );
+ hetri_impl< value_type >::invoke( uplo, a, ipiv, info, work );
     return info;
 }
 
@@ -112,7 +109,7 @@
 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,
+ hetri_impl< value_type >::invoke( uplo, a, ipiv, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -54,12 +52,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -88,7 +85,7 @@
         MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- hetrs_impl< value_type >::compute( uplo, a, ipiv, b, info );
+ hetrs_impl< value_type >::invoke( uplo, a, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -96,13 +94,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHAR,
             typename VectorALPHAI, typename VectorBETA, typename MatrixQ,
             typename MatrixZ, typename WORK >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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,
             integer_t& info, detail::workspace1< WORK > work ) {
@@ -149,13 +147,13 @@
     template< typename MatrixH, typename MatrixT, typename VectorALPHAR,
             typename VectorALPHAI, typename VectorBETA, typename MatrixQ,
             typename MatrixZ >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(h) ) );
- compute( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, z,
+ invoke( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, z,
                 info, workspace( tmp_work ) );
     }
 
@@ -163,7 +161,7 @@
     template< typename MatrixH, typename MatrixT, typename VectorALPHAR,
             typename VectorALPHAI, typename VectorBETA, typename MatrixQ,
             typename MatrixZ >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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,
             integer_t& info, optimal_workspace work ) {
@@ -178,7 +176,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, z,
+ invoke( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, z,
                 info, workspace( tmp_work ) );
     }
 
@@ -193,13 +191,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHA,
             typename VectorBETA, typename MatrixQ, typename MatrixZ,
             typename WORK, typename RWORK >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
@@ -245,7 +243,7 @@
     // minimal workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHA,
             typename VectorBETA, typename MatrixQ, typename MatrixZ >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
@@ -253,14 +251,14 @@
                 traits::matrix_num_columns(h) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(h) ) );
- compute( job, compq, compz, ilo, h, t, alpha, beta, q, z, info,
+ invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixH, typename MatrixT, typename VectorALPHA,
             typename VectorBETA, typename MatrixQ, typename MatrixZ >
- static void compute( char const job, char const compq, char const compz,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
@@ -277,7 +275,7 @@
                 traits::vector_storage(tmp_rwork), info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( job, compq, compz, ilo, h, t, alpha, beta, q, z, info,
+ invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -301,7 +299,7 @@
         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,
+ hgeqz_impl< value_type >::invoke( job, compq, compz, ilo, h, t,
             alphar, alphai, beta, q, z, info, work );
     return info;
 }
@@ -316,7 +314,7 @@
         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,
+ hgeqz_impl< value_type >::invoke( job, compq, compz, ilo, h, t,
             alphar, alphai, beta, q, z, info, optimal_workspace() );
     return info;
 }
@@ -330,7 +328,7 @@
         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,
+ hgeqz_impl< value_type >::invoke( job, compq, compz, ilo, h, t,
             alpha, beta, q, z, info, work );
     return info;
 }
@@ -343,7 +341,7 @@
         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,
+ hgeqz_impl< value_type >::invoke( job, compq, compz, ilo, h, t,
             alpha, beta, q, z, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -64,14 +62,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -115,23 +112,23 @@
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
- workspace( tmp_work, tmp_rwork ) );
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -154,8 +151,8 @@
         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,
- berr, info, work );
+ hprfs_impl< value_type >::invoke( n, ap, afp, ipiv, b, x, ferr, berr,
+ info, work );
     return info;
 }
 
@@ -168,8 +165,8 @@
         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() );
+ hprfs_impl< value_type >::invoke( n, ap, afp, ipiv, b, x, ferr, berr,
+ info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -52,12 +50,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
- static void compute( char const uplo, integer_t const n, MatrixAP& ap,
+ static void invoke( char const uplo, integer_t const n, MatrixAP& ap,
             VectorIPIV& ipiv, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
@@ -82,7 +79,7 @@
         VectorIPIV& ipiv, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
- hptrs_impl< value_type >::compute( uplo, n, ap, ipiv, b, info );
+ hptrs_impl< value_type >::invoke( uplo, n, ap, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -93,13 +91,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixH, typename VectorWR,
             typename VectorWI, typename MatrixVL, typename MatrixVR,
             typename VectorIFAILL, typename VectorIFAILR, typename WORK >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
@@ -149,28 +147,28 @@
     template< typename VectorSELECT, typename MatrixH, typename VectorWR,
             typename VectorWI, typename MatrixVL, typename MatrixVR,
             typename VectorIFAILL, typename VectorIFAILR >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(h), ?2 ) );
- compute( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m,
- ifaill, ifailr, info, workspace( tmp_work ) );
+ invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, ifaill,
+ ifailr, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixH, typename VectorWR,
             typename VectorWI, typename MatrixVL, typename MatrixVR,
             typename VectorIFAILL, typename VectorIFAILR >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m,
- ifaill, ifailr, info, minimal_workspace() );
+ invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, ifaill,
+ ifailr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n, ?? ) {
@@ -184,13 +182,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixH, typename VectorW,
             typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
             typename VectorIFAILR, typename WORK, typename RWORK >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
@@ -237,7 +235,7 @@
     template< typename VectorSELECT, typename MatrixH, typename VectorW,
             typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
             typename VectorIFAILR >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
@@ -246,7 +244,7 @@
                 traits::matrix_num_columns(h) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(h) ) );
- compute( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
+ invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
                 ifailr, info, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -254,12 +252,12 @@
     template< typename VectorSELECT, typename MatrixH, typename VectorW,
             typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
             typename VectorIFAILR >
- static void compute( char const side, char const eigsrc, char const initv,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
+ invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
                 ifailr, info, minimal_workspace() );
     }
 
@@ -285,8 +283,8 @@
     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, work );
+ hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, wr,
+ wi, vl, vr, mm, m, ifaill, ifailr, info, work );
     return info;
 }
 
@@ -301,8 +299,8 @@
     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() );
+ hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, wr,
+ wi, vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
     return info;
 }
 // template function to call hsein
@@ -316,7 +314,7 @@
     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,
+ hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, w,
             vl, vr, mm, m, ifaill, ifailr, info, work );
     return info;
 }
@@ -332,7 +330,7 @@
     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,
+ hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, w,
             vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -83,15 +81,14 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixH, typename VectorWR, typename VectorWI,
             typename MatrixZ, typename WORK >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h,
- VectorWR& wr, VectorWI& wi, MatrixZ& z, integer_t& info,
- detail::workspace1< WORK > work ) {
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorWR& wr, VectorWI& wi,
+ MatrixZ& z, integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::vector_traits<
                 VectorWR >::value_type >::value) );
@@ -118,24 +115,22 @@
     // minimal workspace specialization
     template< typename MatrixH, typename VectorWR, typename VectorWI,
             typename MatrixZ >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h,
- VectorWR& wr, VectorWI& wi, MatrixZ& z, integer_t& info,
- minimal_workspace work ) {
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorWR& wr, VectorWI& wi,
+ MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( job, compz, ilo, ihi, h, wr, wi, z, info,
+ invoke( job, compz, ilo, ihi, h, wr, wi, z, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixH, typename VectorWR, typename VectorWI,
             typename MatrixZ >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h,
- VectorWR& wr, VectorWI& wi, MatrixZ& z, integer_t& info,
- optimal_workspace work ) {
- compute( job, compz, ilo, ihi, h, wr, wi, z, info,
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorWR& wr, VectorWI& wi,
+ MatrixZ& z, integer_t& info, optimal_workspace work ) {
+ invoke( job, compz, ilo, ihi, h, wr, wi, z, info,
                 minimal_workspace() );
     }
 
@@ -150,14 +145,14 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixH, typename VectorW, typename MatrixZ,
             typename WORK >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h, VectorW& w,
- MatrixZ& z, integer_t& info, detail::workspace1< WORK > work ) {
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorW& w, MatrixZ& z,
+ integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::vector_traits<
                 VectorW >::value_type >::value) );
@@ -178,20 +173,20 @@
 
     // minimal workspace specialization
     template< typename MatrixH, typename VectorW, typename MatrixZ >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h, VectorW& w,
- MatrixZ& z, integer_t& info, minimal_workspace work ) {
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorW& w, MatrixZ& z,
+ integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( job, compz, ilo, ihi, h, w, z, info, workspace( tmp_work ) );
+ invoke( job, compz, ilo, ihi, h, w, z, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixH, typename VectorW, typename MatrixZ >
- static void compute( char const job, char const compz,
- integer_t const ilo, integer_t const ihi, MatrixH& h, VectorW& w,
- MatrixZ& z, integer_t& info, optimal_workspace work ) {
- compute( job, compz, ilo, ihi, h, w, z, info, minimal_workspace() );
+ static void invoke( char const job, char const compz, integer_t const ilo,
+ integer_t const ihi, MatrixH& h, VectorW& w, MatrixZ& z,
+ integer_t& info, optimal_workspace work ) {
+ invoke( job, compz, ilo, ihi, h, w, z, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -208,8 +203,8 @@
         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 );
+ hseqr_impl< value_type >::invoke( job, compz, ilo, ihi, h, wr, wi, z,
+ info, work );
     return info;
 }
 
@@ -221,8 +216,8 @@
         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() );
+ hseqr_impl< value_type >::invoke( job, compz, ilo, ihi, h, wr, wi, z,
+ info, optimal_workspace() );
     return info;
 }
 // template function to call hseqr
@@ -233,7 +228,7 @@
         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,
+ hseqr_impl< value_type >::invoke( job, compz, ilo, ihi, h, w, z,
             info, work );
     return info;
 }
@@ -245,7 +240,7 @@
         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,
+ hseqr_impl< value_type >::invoke( job, compz, ilo, ihi, h, w, z,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -79,13 +77,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
             typename MatrixY >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -135,13 +133,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
             typename MatrixY >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq,
             VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
@@ -191,7 +189,7 @@
         VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- labrd_impl< value_type >::compute( a, d, e, tauq, taup, x, y );
+ labrd_impl< value_type >::invoke( a, d, e, tauq, taup, x, y );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -67,11 +65,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorX, typename V, typename ISGN >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, detail::workspace2< V, ISGN > work ) {
         BOOST_ASSERT( n >= 1 );
         BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
@@ -85,18 +83,18 @@
 
     // minimal workspace specialization
     template< typename VectorX >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_v( min_size_v( n ) );
         traits::detail::array< integer_t > tmp_isgn( min_size_isgn( n ) );
- compute( n, x, est, kase, workspace( tmp_v, tmp_isgn ) );
+ invoke( n, x, est, kase, workspace( tmp_v, tmp_isgn ) );
     }
 
     // optimal workspace specialization
     template< typename VectorX >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, optimal_workspace work ) {
- compute( n, x, est, kase, minimal_workspace() );
+ invoke( n, x, est, kase, minimal_workspace() );
     }
 
     static integer_t min_size_v( integer_t const n ) {
@@ -114,11 +112,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorX, typename V >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, detail::workspace1< V > work ) {
         BOOST_ASSERT( n >= 1 );
         BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
@@ -129,17 +127,17 @@
 
     // minimal workspace specialization
     template< typename VectorX >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_v( min_size_v( n ) );
- compute( n, x, est, kase, workspace( tmp_v ) );
+ invoke( n, x, est, kase, workspace( tmp_v ) );
     }
 
     // optimal workspace specialization
     template< typename VectorX >
- static void compute( integer_t const n, VectorX& x, real_type& est,
+ static void invoke( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, optimal_workspace work ) {
- compute( n, x, est, kase, minimal_workspace() );
+ invoke( n, x, est, kase, minimal_workspace() );
     }
 
     static integer_t min_size_v( integer_t const n ) {
@@ -155,7 +153,7 @@
         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 );
+ lacon_impl< value_type >::invoke( n, x, est, kase, work );
     return info;
 }
 
@@ -166,7 +164,7 @@
         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,
+ lacon_impl< value_type >::invoke( n, x, est, kase,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,13 +60,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorE2,
             typename VectorNVAL, typename MatrixAB, typename VectorC,
             typename MatrixNAB, typename WORK, typename IWORK >
- static void compute( integer_t const ijob, integer_t const nitmax,
+ static void invoke( integer_t const ijob, integer_t const nitmax,
             integer_t const n, integer_t const minp, integer_t const nbmin,
             real_type const abstol, real_type const reltol,
             real_type const pivmin, VectorD& d, VectorE& e, VectorE2& e2,
@@ -110,7 +108,7 @@
     template< typename VectorD, typename VectorE, typename VectorE2,
             typename VectorNVAL, typename MatrixAB, typename VectorC,
             typename MatrixNAB >
- static void compute( integer_t const ijob, integer_t const nitmax,
+ static void invoke( integer_t const ijob, integer_t const nitmax,
             integer_t const n, integer_t const minp, integer_t const nbmin,
             real_type const abstol, real_type const reltol,
             real_type const pivmin, VectorD& d, VectorE& e, VectorE2& e2,
@@ -120,7 +118,7 @@
                 traits::leading_dimension(ab) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::leading_dimension(ab) ) );
- compute( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, d, e,
+ invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, d, e,
                 e2, nval, ab, c, mout, nab, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -129,13 +127,13 @@
     template< typename VectorD, typename VectorE, typename VectorE2,
             typename VectorNVAL, typename MatrixAB, typename VectorC,
             typename MatrixNAB >
- static void compute( integer_t const ijob, integer_t const nitmax,
+ static void invoke( integer_t const ijob, integer_t const nitmax,
             integer_t const n, integer_t const minp, integer_t const nbmin,
             real_type const abstol, real_type const reltol,
             real_type const pivmin, VectorD& d, VectorE& e, VectorE2& e2,
             VectorNVAL& nval, MatrixAB& ab, VectorC& c, integer_t& mout,
             MatrixNAB& nab, integer_t& info, optimal_workspace work ) {
- compute( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, d, e,
+ invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, d, e,
                 e2, nval, ab, c, mout, nab, info, minimal_workspace() );
     }
 
@@ -162,7 +160,7 @@
         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,
+ laebz_impl< value_type >::invoke( ijob, nitmax, n, minp, nbmin,
             abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, info,
             work );
     return info;
@@ -181,7 +179,7 @@
         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,
+ laebz_impl< value_type >::invoke( ijob, nitmax, n, minp, nbmin,
             abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, info,
             optimal_workspace() );
     return info;

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorV, typename MatrixC, typename WORK >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, real_type const tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -100,20 +98,20 @@
 
     // minimal workspace specialization
     template< typename VectorV, typename MatrixC >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, real_type const tau, MatrixC& c,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, l, v, incv, tau, c, workspace( tmp_work ) );
+ invoke( side, l, v, incv, tau, c, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorV, typename MatrixC >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, real_type const tau, MatrixC& c,
             optimal_workspace work ) {
- compute( side, l, v, incv, tau, c, minimal_workspace() );
+ invoke( side, l, v, incv, tau, c, minimal_workspace() );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -131,11 +129,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorV, typename MatrixC, typename WORK >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, value_type const tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -156,20 +154,20 @@
 
     // minimal workspace specialization
     template< typename VectorV, typename MatrixC >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, value_type const tau, MatrixC& c,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, l, v, incv, tau, c, workspace( tmp_work ) );
+ invoke( side, l, v, incv, tau, c, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorV, typename MatrixC >
- static void compute( char const side, integer_t const l, VectorV& v,
+ static void invoke( char const side, integer_t const l, VectorV& v,
             integer_t const incv, value_type const tau, MatrixC& c,
             optimal_workspace work ) {
- compute( side, l, v, incv, tau, c, minimal_workspace() );
+ invoke( side, l, v, incv, tau, c, minimal_workspace() );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -189,7 +187,7 @@
         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 );
+ larz_impl< value_type >::invoke( side, l, v, incv, tau, c, work );
     return info;
 }
 
@@ -200,7 +198,7 @@
         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,
+ larz_impl< value_type >::invoke( side, l, v, incv, tau, c,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,12 +69,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorE, typename VectorTAU,
             typename MatrixW >
- static void compute( integer_t const nb, MatrixA& a, VectorE& e,
+ static void invoke( integer_t const nb, MatrixA& a, VectorE& e,
             VectorTAU& tau, MatrixW& w ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -106,12 +104,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorE, typename VectorTAU,
             typename MatrixW >
- static void compute( integer_t const nb, MatrixA& a, VectorE& e,
+ static void invoke( integer_t const nb, MatrixA& a, VectorE& e,
             VectorTAU& tau, MatrixW& w ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -141,7 +139,7 @@
         VectorTAU& tau, MatrixW& w ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- latrd_impl< value_type >::compute( nb, a, e, tau, w );
+ latrd_impl< value_type >::invoke( nb, a, e, tau, w );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -77,11 +75,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorX, typename VectorCNORM >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             char const normin, MatrixA& a, VectorX& x, real_type& scale,
             VectorCNORM& cnorm, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -111,11 +109,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorX, typename VectorCNORM >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             char const normin, MatrixA& a, VectorX& x, real_type& scale,
             VectorCNORM& cnorm, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -145,7 +143,7 @@
         VectorCNORM& cnorm ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- latrs_impl< value_type >::compute( uplo, trans, diag, normin, a, x,
+ latrs_impl< value_type >::invoke( uplo, trans, diag, normin, a, x,
             scale, cnorm, info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,11 +69,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, detail::workspace1<
+ static void invoke( MatrixA& a, VectorTAU& tau, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -97,16 +95,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, minimal_workspace work ) {
+ static void invoke( MatrixA& a, VectorTAU& tau, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a) ) );
- compute( a, tau, workspace( tmp_work ) );
+ invoke( a, tau, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, optimal_workspace work ) {
- compute( a, tau, minimal_workspace() );
+ static void invoke( MatrixA& a, VectorTAU& tau, optimal_workspace work ) {
+ invoke( a, tau, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -120,11 +118,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, detail::workspace1<
+ static void invoke( MatrixA& a, VectorTAU& tau, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -146,16 +144,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, minimal_workspace work ) {
+ static void invoke( MatrixA& a, VectorTAU& tau, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_rows(a) ) );
- compute( a, tau, workspace( tmp_work ) );
+ invoke( a, tau, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, optimal_workspace work ) {
- compute( a, tau, minimal_workspace() );
+ static void invoke( MatrixA& a, VectorTAU& tau, optimal_workspace work ) {
+ invoke( a, tau, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -169,7 +167,7 @@
 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 );
+ latrz_impl< value_type >::invoke( a, tau, work );
     return info;
 }
 
@@ -178,7 +176,7 @@
 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() );
+ latrz_impl< value_type >::invoke( a, tau, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -52,12 +50,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ,
             typename WORK >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::vector_traits<
@@ -84,18 +82,18 @@
 
     // minimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(q) ) );
- compute( uplo, ap, tau, q, info, workspace( tmp_work ) );
+ invoke( uplo, ap, tau, q, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( uplo, ap, tau, q, info, minimal_workspace() );
+ invoke( uplo, ap, tau, q, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -111,7 +109,7 @@
         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 );
+ opgtr_impl< value_type >::invoke( uplo, ap, tau, q, info, work );
     return info;
 }
 
@@ -121,7 +119,7 @@
         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,
+ opgtr_impl< value_type >::invoke( uplo, ap, tau, q, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -54,12 +52,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -87,20 +85,20 @@
 
     // minimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, uplo, trans, ap, tau, c, info, workspace( tmp_work ) );
+ invoke( side, uplo, trans, ap, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
- compute( side, uplo, trans, ap, tau, c, info, minimal_workspace() );
+ invoke( side, uplo, trans, ap, tau, c, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -121,7 +119,7 @@
         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,
+ opmtr_impl< value_type >::invoke( side, uplo, trans, ap, tau, c,
             info, work );
     return info;
 }
@@ -132,7 +130,7 @@
         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,
+ opmtr_impl< value_type >::invoke( side, uplo, trans, ap, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,13 +51,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, detail::workspace1< WORK > work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
@@ -77,25 +75,25 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, minimal_workspace work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( m, n ) );
- compute( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, optimal_workspace work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ optimal_workspace work ) {
         real_type opt_size_work;
         detail::orgbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m, integer_t const n ) {
@@ -111,8 +109,7 @@
         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,
- work );
+ orgbr_impl< value_type >::invoke( vect, m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -122,7 +119,7 @@
         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,
+ orgbr_impl< value_type >::invoke( vect, m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -76,17 +74,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -95,7 +93,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -110,7 +108,7 @@
         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 );
+ orghr_impl< value_type >::invoke( n, ilo, ihi, a, tau, info, work );
     return info;
 }
 
@@ -120,7 +118,7 @@
         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,
+ orghr_impl< value_type >::invoke( n, ilo, ihi, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -78,16 +76,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( m ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -96,7 +94,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -111,7 +109,7 @@
         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 );
+ orglq_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -121,7 +119,7 @@
         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,
+ orglq_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -78,16 +76,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -96,7 +94,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -111,7 +109,7 @@
         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 );
+ orgql_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -121,7 +119,7 @@
         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,
+ orgql_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -78,16 +76,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -96,7 +94,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -111,7 +109,7 @@
         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 );
+ orgqr_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -121,7 +119,7 @@
         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,
+ orgqr_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -78,16 +76,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( m ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -96,7 +94,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -111,7 +109,7 @@
         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 );
+ orgrq_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -121,7 +119,7 @@
         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,
+ orgrq_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,11 +51,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -78,15 +76,15 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( n, a, tau, info, workspace( tmp_work ) );
+ invoke( n, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::orgtr( traits::matrix_uplo_tag(a), n,
@@ -94,7 +92,7 @@
                 traits::vector_storage(tau), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( n, a, tau, info, workspace( tmp_work ) );
+ invoke( n, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -109,7 +107,7 @@
         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 );
+ orgtr_impl< value_type >::invoke( n, a, tau, info, work );
     return info;
 }
 
@@ -118,7 +116,7 @@
 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,
+ orgtr_impl< value_type >::invoke( n, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -94,18 +92,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( vect, side, trans, k, a, tau, c, info,
- workspace( tmp_work ) );
+ invoke( vect, side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
@@ -116,8 +113,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( vect, side, trans, k, a, tau, c, info,
- workspace( tmp_work ) );
+ invoke( vect, side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -138,7 +134,7 @@
         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,
+ ormbr_impl< value_type >::invoke( vect, side, trans, k, a, tau, c,
             info, work );
     return info;
 }
@@ -150,7 +146,7 @@
         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,
+ ormbr_impl< value_type >::invoke( vect, side, trans, k, a, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,12 +57,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info, detail::workspace1<
             WORK > work ) {
@@ -94,19 +92,19 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, ilo, ihi, a, tau, c, info,
+ invoke( side, trans, ilo, ihi, a, tau, c, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
@@ -118,7 +116,7 @@
                 traits::leading_dimension(c), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, ilo, ihi, a, tau, c, info,
+ invoke( side, trans, ilo, ihi, a, tau, c, info,
                 workspace( tmp_work ) );
     }
 
@@ -140,7 +138,7 @@
         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,
+ ormhr_impl< value_type >::invoke( side, trans, ilo, ihi, a, tau, c,
             info, work );
     return info;
 }
@@ -152,7 +150,7 @@
         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,
+ ormhr_impl< value_type >::invoke( side, trans, ilo, ihi, a, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,12 +55,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -92,17 +90,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -113,7 +111,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -134,7 +132,7 @@
         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,
+ ormlq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -145,7 +143,7 @@
         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,
+ ormlq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,12 +55,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -91,17 +89,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -112,7 +110,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -133,7 +131,7 @@
         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,
+ ormql_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -144,7 +142,7 @@
         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,
+ ormql_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,12 +55,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -91,17 +89,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -112,7 +110,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -133,7 +131,7 @@
         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,
+ ormqr_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -144,7 +142,7 @@
         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,
+ ormqr_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,12 +55,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -92,17 +90,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -113,7 +111,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -134,7 +132,7 @@
         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,
+ ormrq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -145,7 +143,7 @@
         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,
+ ormrq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -93,17 +91,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -115,7 +113,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -132,7 +130,7 @@
         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,
+ ormrz_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -143,7 +141,7 @@
         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,
+ ormrz_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,12 +55,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -93,17 +91,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
@@ -114,7 +112,7 @@
                 traits::leading_dimension(c), &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -134,7 +132,7 @@
         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,
+ ormtr_impl< value_type >::invoke( side, trans, a, tau, c, info,
             work );
     return info;
 }
@@ -145,7 +143,7 @@
         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,
+ ormtr_impl< value_type >::invoke( side, trans, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename IWORK >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -99,21 +97,21 @@
 
     // minimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( uplo, n, kd, ab, anorm, rcond, info, workspace( tmp_work,
+ invoke( uplo, n, kd, ab, anorm, rcond, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( uplo, n, kd, ab, anorm, rcond, info, minimal_workspace() );
+ invoke( uplo, n, kd, ab, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -131,11 +129,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename RWORK >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -155,21 +153,21 @@
 
     // minimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( uplo, n, kd, ab, anorm, rcond, info, workspace( tmp_work,
+ invoke( uplo, n, kd, ab, anorm, rcond, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( uplo, n, kd, ab, anorm, rcond, info, minimal_workspace() );
+ invoke( uplo, n, kd, ab, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -190,7 +188,7 @@
         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,
+ pbcon_impl< value_type >::invoke( uplo, n, kd, ab, anorm, rcond,
             info, work );
     return info;
 }
@@ -203,7 +201,7 @@
         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,
+ pbcon_impl< value_type >::invoke( uplo, n, kd, ab, anorm, rcond,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -69,11 +67,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorS >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             VectorS& s, real_type& scond, real_type& amax, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
@@ -95,11 +93,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename VectorS >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             VectorS& s, real_type& scond, real_type& amax, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -121,7 +119,7 @@
         MatrixAB >::value_type& amax ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- pbequ_impl< value_type >::compute( n, kd, ab, s, scond, amax, info );
+ pbequ_impl< value_type >::invoke( n, kd, ab, s, scond, amax, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename IWORK >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -142,22 +139,22 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( n, kd, ab, afb, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( n, kd, ab, afb, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( n, kd, ab, afb, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( n, kd, ab, afb, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -175,14 +172,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename RWORK >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -227,22 +223,22 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( n, kd, ab, afb, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( n, kd, ab, afb, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             MatrixAFB& afb, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( n, kd, ab, afb, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( n, kd, ab, afb, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -264,7 +260,7 @@
         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,
+ pbrfs_impl< value_type >::invoke( n, kd, ab, afb, b, x, ferr, berr,
             info, work );
     return info;
 }
@@ -277,7 +273,7 @@
         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,
+ pbrfs_impl< value_type >::invoke( n, kd, ab, afb, b, x, ferr, berr,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -80,7 +78,7 @@
         MatrixAB& ab ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- pbstf_impl< value_type >::compute( n, kd, ab, info );
+ pbstf_impl< value_type >::invoke( n, kd, ab, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB >
- static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
+ static void invoke( integer_t const n, integer_t const kd, MatrixAB& ab,
             integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -80,7 +78,7 @@
         MatrixAB& ab ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- pbtrf_impl< value_type >::compute( n, kd, ab, info );
+ pbtrf_impl< value_type >::invoke( n, kd, ab, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,12 +60,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename MatrixB >
- static void compute( char const uplo, integer_t const n,
+ static void invoke( char const uplo, integer_t const n,
             integer_t const kd, MatrixAB& ab, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
@@ -92,7 +89,7 @@
         integer_t const kd, MatrixAB& ab, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- pbtrs_impl< value_type >::compute( uplo, n, kd, ab, b, info );
+ pbtrs_impl< value_type >::invoke( uplo, n, kd, ab, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -99,20 +97,20 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, anorm, rcond, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( a, anorm, rcond, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, optimal_workspace work ) {
- compute( a, anorm, rcond, info, minimal_workspace() );
+ invoke( a, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -130,11 +128,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -154,20 +152,20 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, anorm, rcond, info, workspace( tmp_work, tmp_rwork ) );
+ invoke( a, anorm, rcond, info, workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
+ static void invoke( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, optimal_workspace work ) {
- compute( a, anorm, rcond, info, minimal_workspace() );
+ invoke( a, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -187,7 +185,7 @@
         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 );
+ pocon_impl< value_type >::invoke( a, anorm, rcond, info, work );
     return info;
 }
 
@@ -198,7 +196,7 @@
         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,
+ pocon_impl< value_type >::invoke( a, anorm, rcond, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -67,11 +65,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorS >
- static void compute( MatrixA& a, VectorS& s, real_type& scond,
+ static void invoke( MatrixA& a, VectorS& s, real_type& scond,
             real_type& amax, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -91,11 +89,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorS >
- static void compute( MatrixA& a, VectorS& s, real_type& scond,
+ static void invoke( MatrixA& a, VectorS& s, real_type& scond,
             real_type& amax, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
         BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
@@ -114,7 +112,7 @@
         typename traits::matrix_traits< MatrixA >::value_type& amax ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- poequ_impl< value_type >::compute( a, s, scond, amax, info );
+ poequ_impl< value_type >::invoke( a, s, scond, amax, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename IWORK >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -144,24 +141,24 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, af, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( a, af, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( a, af, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( a, af, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -179,14 +176,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename RWORK >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -233,24 +229,24 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, af, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( a, af, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixAF, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, MatrixAF& af, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( a, af, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( a, af, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -271,7 +267,7 @@
         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,
+ porfs_impl< value_type >::invoke( a, af, b, x, ferr, berr, info,
             work );
     return info;
 }
@@ -283,7 +279,7 @@
         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,
+ porfs_impl< value_type >::invoke( a, af, b, x, ferr, berr, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, integer_t& info ) {
+ static void invoke( MatrixA& a, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -78,7 +76,7 @@
 inline integer_t potrf( MatrixA& a ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- potrf_impl< value_type >::compute( a, info );
+ potrf_impl< value_type >::invoke( a, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA >
- static void compute( MatrixA& a, integer_t& info ) {
+ static void invoke( MatrixA& a, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -78,7 +76,7 @@
 inline integer_t potri( MatrixA& a ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- potri_impl< value_type >::compute( a, info );
+ potri_impl< value_type >::invoke( a, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,12 +60,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB >
- static void compute( MatrixA& a, MatrixB& b, integer_t& info ) {
+ static void invoke( MatrixA& a, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
@@ -93,7 +90,7 @@
 inline integer_t potrs( MatrixA& a, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- potrs_impl< value_type >::compute( a, b, info );
+ potrs_impl< value_type >::invoke( a, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -85,14 +83,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename IWORK >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -136,22 +133,22 @@
     // minimal workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( n, ap, afp, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( n, ap, afp, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, optimal_workspace work ) {
- compute( n, ap, afp, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( n, ap, afp, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -169,14 +166,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename RWORK >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -217,22 +213,22 @@
     // minimal workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( n, ap, afp, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( n, ap, afp, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename VectorAFP, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, VectorAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, VectorAFP& afp,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, optimal_workspace work ) {
- compute( n, ap, afp, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( n, ap, afp, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -254,8 +250,8 @@
         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,
- info, work );
+ pprfs_impl< value_type >::invoke( n, ap, afp, b, x, ferr, berr, info,
+ work );
     return info;
 }
 
@@ -266,8 +262,8 @@
         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() );
+ pprfs_impl< value_type >::invoke( n, ap, afp, b, x, ferr, berr, info,
+ optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,11 +60,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorAP, typename MatrixB >
- static void compute( integer_t const n, VectorAP& ap, MatrixB& b,
+ static void invoke( integer_t const n, VectorAP& ap, MatrixB& b,
             integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
@@ -89,7 +87,7 @@
 inline integer_t pptrs( integer_t const n, VectorAP& ap, MatrixB& b ) {
     typedef typename traits::vector_traits< VectorAP >::value_type value_type;
     integer_t info(0);
- pptrs_impl< value_type >::compute( n, ap, b, info );
+ pptrs_impl< value_type >::invoke( n, ap, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,12 +69,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -99,17 +97,17 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
- compute( compz, n, d, e, z, info, minimal_workspace() );
+ invoke( compz, n, d, e, z, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -123,12 +121,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -148,17 +146,17 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
- compute( compz, n, d, e, z, info, minimal_workspace() );
+ invoke( compz, n, d, e, z, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -174,7 +172,7 @@
         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 );
+ pteqr_impl< value_type >::invoke( compz, n, d, e, z, info, work );
     return info;
 }
 
@@ -184,7 +182,7 @@
         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,
+ pteqr_impl< value_type >::invoke( compz, n, d, e, z, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -85,13 +83,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace1< WORK > work ) {
@@ -141,12 +139,12 @@
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( n, d, e, df, ef, b, x, ferr, berr, info,
+ invoke( n, d, e, df, ef, b, x, ferr, berr, info,
                 workspace( tmp_work ) );
     }
 
@@ -154,12 +152,11 @@
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( n, d, e, df, ef, b, x, ferr, berr, info,
- minimal_workspace() );
+ invoke( n, d, e, df, ef, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -173,14 +170,14 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename RWORK >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
@@ -231,13 +228,13 @@
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( uplo, n, d, e, df, ef, b, x, ferr, berr, info,
+ invoke( uplo, n, d, e, df, ef, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -245,11 +242,11 @@
     template< typename VectorD, typename VectorE, typename VectorDF,
             typename VectorEF, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, VectorDF& df, VectorEF& ef, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, n, d, e, df, ef, b, x, ferr, berr, info,
+ invoke( uplo, n, d, e, df, ef, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -272,7 +269,7 @@
         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,
+ ptrfs_impl< value_type >::invoke( n, d, e, df, ef, b, x, ferr, berr,
             info, work );
     return info;
 }
@@ -286,7 +283,7 @@
         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,
+ ptrfs_impl< value_type >::invoke( n, d, e, df, ef, b, x, ferr, berr,
             info, optimal_workspace() );
     return info;
 }
@@ -299,7 +296,7 @@
         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,
+ ptrfs_impl< value_type >::invoke( uplo, n, d, e, df, ef, b, x, ferr,
             berr, info, work );
     return info;
 }
@@ -313,7 +310,7 @@
         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,
+ ptrfs_impl< value_type >::invoke( uplo, n, d, e, df, ef, b, x, ferr,
             berr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -67,12 +65,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
- MatrixB& b, integer_t& info ) {
+ static void invoke( integer_t const n, VectorD& d, VectorE& e, MatrixB& b,
+ integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
@@ -97,11 +95,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::B > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorD, typename VectorE, typename MatrixB >
- static void compute( char const uplo, integer_t const n, VectorD& d,
+ static void invoke( char const uplo, integer_t const n, VectorD& d,
             VectorE& e, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorE >::value_type, typename traits::matrix_traits<
@@ -125,7 +123,7 @@
         MatrixB& b ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
- pttrs_impl< value_type >::compute( n, d, e, b, info );
+ pttrs_impl< value_type >::invoke( n, d, e, b, info );
     return info;
 }
 // template function to call pttrs
@@ -134,7 +132,7 @@
         VectorE& e, MatrixB& b ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
- pttrs_impl< value_type >::compute( uplo, n, d, e, b, info );
+ pttrs_impl< value_type >::invoke( uplo, n, d, e, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,12 +54,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
             typename WORK >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info, detail::workspace1<
             WORK > work ) {
@@ -90,21 +88,21 @@
 
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( vect, n, ka, kb, ab, bb, x, info, workspace( tmp_work ) );
+ invoke( vect, n, ka, kb, ab, bb, x, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const ka, integer_t const kb, MatrixAB& ab,
             MatrixBB& bb, MatrixX& x, integer_t& info,
             optimal_workspace work ) {
- compute( vect, n, ka, kb, ab, bb, x, info, minimal_workspace() );
+ invoke( vect, n, ka, kb, ab, bb, x, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -121,7 +119,7 @@
         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,
+ sbgst_impl< value_type >::invoke( vect, n, ka, kb, ab, bb, x, info,
             work );
     return info;
 }
@@ -133,7 +131,7 @@
         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,
+ sbgst_impl< value_type >::invoke( vect, n, ka, kb, ab, bb, x, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,12 +54,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename WORK >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -92,20 +90,20 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( vect, n, kd, ab, d, e, q, info, workspace( tmp_work ) );
+ invoke( vect, n, kd, ab, d, e, q, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static void compute( char const vect, integer_t const n,
+ static void invoke( char const vect, integer_t const n,
             integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
             MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( vect, n, kd, ab, d, e, q, info, minimal_workspace() );
+ invoke( vect, n, kd, ab, d, e, q, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -122,7 +120,7 @@
         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,
+ sbtrd_impl< value_type >::invoke( vect, n, kd, ab, d, e, q, info,
             work );
     return info;
 }
@@ -135,7 +133,7 @@
         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,
+ sbtrd_impl< value_type >::invoke( vect, n, kd, ab, d, e, q, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename IWORK >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -141,23 +138,23 @@
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
- workspace( tmp_work, tmp_iwork ) );
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -176,14 +173,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -227,23 +223,23 @@
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
- workspace( tmp_work, tmp_rwork ) );
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
+ static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
             VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( n, ap, afp, ipiv, b, x, ferr, berr, info,
+ invoke( n, ap, afp, ipiv, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -266,8 +262,8 @@
         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,
- berr, info, work );
+ sprfs_impl< value_type >::invoke( n, ap, afp, ipiv, b, x, ferr, berr,
+ info, work );
     return info;
 }
 
@@ -280,8 +276,8 @@
         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() );
+ sprfs_impl< value_type >::invoke( n, ap, afp, ipiv, b, x, ferr, berr,
+ info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,12 +60,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
- static void compute( char const uplo, integer_t const n, MatrixAP& ap,
+ static void invoke( char const uplo, integer_t const n, MatrixAP& ap,
             VectorIPIV& ipiv, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
@@ -92,7 +89,7 @@
         VectorIPIV& ipiv, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
- sptrs_impl< value_type >::compute( uplo, n, ap, ipiv, b, info );
+ sptrs_impl< value_type >::invoke( uplo, n, ap, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -60,18 +58,18 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename WORK,
             typename IWORK >
- static void compute( char const range, char const order,
- integer_t const n, real_type const vl, real_type const vu,
- integer_t const il, integer_t const iu, real_type const abstol,
- VectorD& d, VectorE& e, integer_t& m, integer_t& nsplit,
- VectorW& w, VectorIBLOCK& iblock, VectorISPLIT& isplit,
- integer_t& info, detail::workspace2< WORK, IWORK > work ) {
+ static void invoke( char const range, char const order, integer_t const n,
+ real_type const vl, real_type const vu, integer_t const il,
+ integer_t const iu, real_type const abstol, VectorD& d,
+ VectorE& e, integer_t& m, integer_t& nsplit, VectorW& w,
+ VectorIBLOCK& iblock, VectorISPLIT& isplit, integer_t& info,
+ detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
@@ -104,28 +102,28 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT >
- static void compute( char const range, char const order,
- integer_t const n, real_type const vl, real_type const vu,
- integer_t const il, integer_t const iu, real_type const abstol,
- VectorD& d, VectorE& e, integer_t& m, integer_t& nsplit,
- VectorW& w, VectorIBLOCK& iblock, VectorISPLIT& isplit,
- integer_t& info, minimal_workspace work ) {
+ static void invoke( char const range, char const order, integer_t const n,
+ real_type const vl, real_type const vu, integer_t const il,
+ integer_t const iu, real_type const abstol, VectorD& d,
+ VectorE& e, integer_t& m, integer_t& nsplit, VectorW& w,
+ VectorIBLOCK& iblock, VectorISPLIT& isplit, integer_t& info,
+ minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w,
+ invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w,
                 iblock, isplit, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT >
- static void compute( char const range, char const order,
- integer_t const n, real_type const vl, real_type const vu,
- integer_t const il, integer_t const iu, real_type const abstol,
- VectorD& d, VectorE& e, integer_t& m, integer_t& nsplit,
- VectorW& w, VectorIBLOCK& iblock, VectorISPLIT& isplit,
- integer_t& info, optimal_workspace work ) {
- compute( range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w,
+ static void invoke( char const range, char const order, integer_t const n,
+ real_type const vl, real_type const vu, integer_t const il,
+ integer_t const iu, real_type const abstol, VectorD& d,
+ VectorE& e, integer_t& m, integer_t& nsplit, VectorW& w,
+ VectorIBLOCK& iblock, VectorISPLIT& isplit, integer_t& info,
+ optimal_workspace work ) {
+ invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w,
                 iblock, isplit, info, minimal_workspace() );
     }
 
@@ -152,7 +150,7 @@
         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,
+ stebz_impl< value_type >::invoke( range, order, n, vl, vu, il, iu,
             abstol, d, e, m, nsplit, w, iblock, isplit, info, work );
     return info;
 }
@@ -170,7 +168,7 @@
         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,
+ stebz_impl< value_type >::invoke( range, order, n, vl, vu, il, iu,
             abstol, d, e, m, nsplit, w, iblock, isplit, info,
             optimal_workspace() );
     return info;

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -82,12 +80,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK, typename IWORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -114,18 +112,18 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( compz,
                 n ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         integer_t opt_size_iwork;
@@ -136,7 +134,7 @@
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -154,12 +152,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK, typename RWORK, typename IWORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace3< WORK,
             RWORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -187,7 +185,7 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -195,13 +193,13 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( compz,
                 n ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work, tmp_rwork,
+ invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_rwork,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         real_type opt_size_rwork;
@@ -215,7 +213,7 @@
         traits::detail::array< real_type > tmp_rwork(
                 traits::detail::to_int( opt_size_rwork ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( compz, n, d, e, z, info, workspace( tmp_work, tmp_rwork,
+ invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_rwork,
                 tmp_iwork ) );
     }
 
@@ -240,7 +238,7 @@
         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 );
+ stedc_impl< value_type >::invoke( compz, n, d, e, z, info, work );
     return info;
 }
 
@@ -250,7 +248,7 @@
         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,
+ stedc_impl< value_type >::invoke( compz, n, d, e, z, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -89,13 +87,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ, typename WORK,
             typename IWORK >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -132,7 +130,7 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -141,14 +139,14 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
- isuppz, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, isuppz,
+ info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -163,8 +161,8 @@
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
- isuppz, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, isuppz,
+ info, workspace( tmp_work, tmp_iwork ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -182,13 +180,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ, typename WORK,
             typename IWORK >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -222,7 +220,7 @@
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -231,14 +229,14 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
- isuppz, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, isuppz,
+ info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename MatrixZ, typename VectorISUPPZ >
- static void compute( char const jobz, char const range, integer_t const n,
+ static void invoke( char const jobz, char const range, integer_t const n,
             VectorD& d, VectorE& e, real_type const vl, real_type const vu,
             integer_t const il, integer_t const iu, real_type const abstol,
             integer_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz,
@@ -253,8 +251,8 @@
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
- isuppz, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, isuppz,
+ info, workspace( tmp_work, tmp_iwork ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -280,7 +278,7 @@
         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,
+ stegr_impl< value_type >::invoke( jobz, range, n, d, e, vl, vu, il,
             iu, abstol, m, w, z, isuppz, info, work );
     return info;
 }
@@ -297,7 +295,7 @@
         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,
+ stegr_impl< value_type >::invoke( jobz, range, n, d, e, vl, vu, il,
             iu, abstol, m, w, z, isuppz, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -78,13 +76,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL, typename WORK, typename IWORK >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
@@ -127,13 +125,13 @@
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( n, d, e, m, w, iblock, isplit, z, ifail, info,
+ invoke( n, d, e, m, w, iblock, isplit, z, ifail, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -141,11 +139,11 @@
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, optimal_workspace work ) {
- compute( n, d, e, m, w, iblock, isplit, z, ifail, info,
+ invoke( n, d, e, m, w, iblock, isplit, z, ifail, info,
                 minimal_workspace() );
     }
 
@@ -164,13 +162,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL, typename WORK, typename IWORK >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
@@ -210,13 +208,13 @@
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( n, d, e, m, w, iblock, isplit, z, ifail, info,
+ invoke( n, d, e, m, w, iblock, isplit, z, ifail, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -224,11 +222,11 @@
     template< typename VectorD, typename VectorE, typename VectorW,
             typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ,
             typename VectorIFAIL >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t const m, VectorW& w, VectorIBLOCK& iblock,
             VectorISPLIT& isplit, MatrixZ& z, VectorIFAIL& ifail,
             integer_t& info, optimal_workspace work ) {
- compute( n, d, e, m, w, iblock, isplit, z, ifail, info,
+ invoke( n, d, e, m, w, iblock, isplit, z, ifail, info,
                 minimal_workspace() );
     }
 
@@ -252,7 +250,7 @@
         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,
+ stein_impl< value_type >::invoke( n, d, e, m, w, iblock, isplit, z,
             ifail, info, work );
     return info;
 }
@@ -266,7 +264,7 @@
         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,
+ stein_impl< value_type >::invoke( n, d, e, m, w, iblock, isplit, z,
             ifail, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,12 +69,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -98,18 +96,18 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
- compute( compz, n, d, e, z, info, minimal_workspace() );
+ invoke( compz, n, d, e, z, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -123,12 +121,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ,
             typename WORK >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -147,18 +145,18 @@
 
     // minimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( compz, n, d, e, z, info, workspace( tmp_work ) );
+ invoke( compz, n, d, e, z, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorD, typename VectorE, typename MatrixZ >
- static void compute( char const compz, integer_t const n, VectorD& d,
+ static void invoke( char const compz, integer_t const n, VectorD& d,
             VectorE& e, MatrixZ& z, integer_t& info, optimal_workspace work ) {
- compute( compz, n, d, e, z, info, minimal_workspace() );
+ invoke( compz, n, d, e, z, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -174,7 +172,7 @@
         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 );
+ steqr_impl< value_type >::invoke( compz, n, d, e, z, info, work );
     return info;
 }
 
@@ -184,7 +182,7 @@
         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,
+ steqr_impl< value_type >::invoke( compz, n, d, e, z, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -48,11 +46,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename VectorD, typename VectorE >
- static void compute( integer_t const n, VectorD& d, VectorE& e,
+ static void invoke( integer_t const n, VectorD& d, VectorE& e,
             integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
@@ -70,7 +68,7 @@
 inline integer_t sterf( integer_t const n, VectorD& d, VectorE& e ) {
     typedef typename traits::vector_traits< VectorD >::value_type value_type;
     integer_t info(0);
- sterf_impl< value_type >::compute( n, d, e, info );
+ sterf_impl< value_type >::invoke( n, d, e, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,13 +73,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK,
             typename IWORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace2< WORK, IWORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
@@ -103,23 +100,23 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work,
+ invoke( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -137,12 +134,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
@@ -161,20 +157,20 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work ) );
+ invoke( uplo, a, ipiv, anorm, rcond, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, anorm, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -191,7 +187,7 @@
         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,
+ sycon_impl< value_type >::invoke( uplo, a, ipiv, anorm, rcond, info,
             work );
     return info;
 }
@@ -203,7 +199,7 @@
         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,
+ sycon_impl< value_type >::invoke( uplo, a, ipiv, anorm, rcond, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -50,12 +48,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB >
- static void compute( integer_t const itype, integer_t const n, MatrixA& a,
+ static void invoke( integer_t const itype, integer_t const n, MatrixA& a,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -79,7 +76,7 @@
         MatrixA& a, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- sygst_impl< value_type >::compute( itype, n, a, b, info );
+ sygst_impl< value_type >::invoke( itype, n, a, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename IWORK >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -148,14 +145,14 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -163,10 +160,10 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, optimal_workspace work ) {
- compute( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -184,14 +181,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -242,14 +238,14 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
+ invoke( a, af, ipiv, b, x, ferr, berr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -257,10 +253,10 @@
     template< typename MatrixA, typename MatrixAF, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static void compute( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
+ static void invoke( MatrixA& a, MatrixAF& af, VectorIPIV& ipiv,
             MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             integer_t& info, optimal_workspace work ) {
- compute( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
+ invoke( a, af, ipiv, b, x, ferr, berr, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -282,7 +278,7 @@
         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,
+ syrfs_impl< value_type >::invoke( a, af, ipiv, b, x, ferr, berr,
             info, work );
     return info;
 }
@@ -295,7 +291,7 @@
         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,
+ syrfs_impl< value_type >::invoke( a, af, ipiv, b, x, ferr, berr,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -53,12 +51,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -91,17 +89,17 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, d, e, tau, info, workspace( tmp_work ) );
+ invoke( a, d, e, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorD, typename VectorE,
             typename VectorTAU >
- static void compute( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
+ static void invoke( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
         detail::sytrd( traits::matrix_uplo_tag(a),
@@ -111,7 +109,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, d, e, tau, info, workspace( tmp_work ) );
+ invoke( a, d, e, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -127,7 +125,7 @@
         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 );
+ sytrd_impl< value_type >::invoke( a, d, e, tau, info, work );
     return info;
 }
 
@@ -138,7 +136,7 @@
         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,
+ sytrd_impl< value_type >::invoke( a, d, e, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -72,12 +70,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -95,16 +92,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::sytrf( traits::matrix_uplo_tag(a),
@@ -113,7 +110,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -127,12 +124,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
@@ -150,16 +146,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::sytrf( traits::matrix_uplo_tag(a),
@@ -168,7 +164,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, ipiv, info, workspace( tmp_work ) );
+ invoke( a, ipiv, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -182,7 +178,7 @@
 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 );
+ sytrf_impl< value_type >::invoke( a, ipiv, info, work );
     return info;
 }
 
@@ -191,7 +187,7 @@
 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,
+ sytrf_impl< value_type >::invoke( a, ipiv, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -71,12 +69,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -94,18 +91,18 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, info, workspace( tmp_work ) );
+ invoke( uplo, a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, optimal_workspace work ) {
- compute( uplo, a, ipiv, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -119,12 +116,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename WORK >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
         BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
@@ -142,18 +138,18 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, a, ipiv, info, workspace( tmp_work ) );
+ invoke( uplo, a, ipiv, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, optimal_workspace work ) {
- compute( uplo, a, ipiv, info, minimal_workspace() );
+ invoke( uplo, a, ipiv, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -168,7 +164,7 @@
         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 );
+ sytri_impl< value_type >::invoke( uplo, a, ipiv, info, work );
     return info;
 }
 
@@ -177,7 +173,7 @@
 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,
+ sytri_impl< value_type >::invoke( uplo, a, ipiv, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -65,12 +63,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >
- static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
+ static void invoke( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -99,7 +96,7 @@
         MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- sytrs_impl< value_type >::compute( uplo, a, ipiv, b, info );
+ sytrs_impl< value_type >::invoke( uplo, a, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -77,11 +75,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename IWORK >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -103,21 +101,21 @@
 
     // minimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( norm, uplo, diag, n, kd, ab, rcond, info,
- workspace( tmp_work, tmp_iwork ) );
+ invoke( norm, uplo, diag, n, kd, ab, rcond, info, workspace( tmp_work,
+ tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( norm, uplo, diag, n, kd, ab, rcond, info,
+ invoke( norm, uplo, diag, n, kd, ab, rcond, info,
                 minimal_workspace() );
     }
 
@@ -136,11 +134,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename WORK, typename RWORK >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -162,21 +160,21 @@
 
     // minimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( norm, uplo, diag, n, kd, ab, rcond, info,
- workspace( tmp_work, tmp_rwork ) );
+ invoke( norm, uplo, diag, n, kd, ab, rcond, info, workspace( tmp_work,
+ tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, optimal_workspace work ) {
- compute( norm, uplo, diag, n, kd, ab, rcond, info,
+ invoke( norm, uplo, diag, n, kd, ab, rcond, info,
                 minimal_workspace() );
     }
 
@@ -198,8 +196,8 @@
         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,
- rcond, info, work );
+ tbcon_impl< value_type >::invoke( norm, uplo, diag, n, kd, ab, rcond,
+ info, work );
     return info;
 }
 
@@ -210,8 +208,8 @@
         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() );
+ tbcon_impl< value_type >::invoke( norm, uplo, diag, n, kd, ab, rcond,
+ info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename IWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             detail::workspace2< WORK, IWORK > work ) {
@@ -138,24 +135,24 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -174,14 +171,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename RWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
@@ -222,24 +218,24 @@
     // minimal workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, kd, ab, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -262,8 +258,8 @@
         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,
- x, ferr, berr, info, work );
+ tbrfs_impl< value_type >::invoke( uplo, trans, diag, n, kd, ab, b, x,
+ ferr, berr, info, work );
     return info;
 }
 
@@ -275,8 +271,8 @@
         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() );
+ tbrfs_impl< value_type >::invoke( uplo, trans, diag, n, kd, ab, b, x,
+ ferr, berr, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -70,12 +68,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAB, typename MatrixB >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, integer_t const kd, MatrixAB& ab, MatrixB& b,
             integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -104,7 +101,7 @@
         MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- tbtrs_impl< value_type >::compute( uplo, trans, diag, n, kd, ab, b,
+ tbtrs_impl< value_type >::invoke( uplo, trans, diag, n, kd, ab, b,
             info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,12 +85,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR, typename WORK >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, detail::workspace1< WORK > work ) {
@@ -124,23 +122,23 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
- compute( side, howmny, select, n, s, p, vl, vr, mm, m, info,
+ invoke( side, howmny, select, n, s, p, vl, vr, mm, m, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, optimal_workspace work ) {
- compute( side, howmny, select, n, s, p, vl, vr, mm, m, info,
+ invoke( side, howmny, select, n, s, p, vl, vr, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -155,13 +153,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR, typename WORK,
             typename RWORK >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
@@ -196,24 +194,24 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( side, howmny, select, n, s, p, vl, vr, mm, m, info,
+ invoke( side, howmny, select, n, s, p, vl, vr, mm, m, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( 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,
             integer_t& info, optimal_workspace work ) {
- compute( side, howmny, select, n, s, p, vl, vr, mm, m, info,
+ invoke( side, howmny, select, n, s, p, vl, vr, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -237,7 +235,7 @@
     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,
+ tgevc_impl< value_type >::invoke( side, howmny, select, n, s, p, vl,
             vr, mm, m, info, work );
     return info;
 }
@@ -251,7 +249,7 @@
     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,
+ tgevc_impl< value_type >::invoke( side, howmny, select, n, s, p, vl,
             vr, mm, m, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -84,13 +82,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
- static void compute( logical_t const wantq, logical_t const wantz,
+ static void invoke( logical_t const wantq, logical_t const wantz,
             integer_t const n, MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
             integer_t& ifst, integer_t& ilst, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -123,13 +120,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ, $WORKSPACE_TYPENAMES >
- static void compute( logical_t const wantq, logical_t const wantz,
+ static void invoke( 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, integer_t& info,
             detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > work ) {
@@ -155,19 +151,19 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
- static void compute( logical_t const wantq, logical_t const wantz,
+ static void invoke( 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, integer_t& info,
             minimal_workspace work ) {
 $SETUP_MIN_WORKARRAYS_POST
- compute( wantq, wantz, n, a, b, q, z, ifst, ilst, info,
+ invoke( wantq, wantz, n, a, b, q, z, ifst, ilst, info,
                 workspace( $TMP_WORKARRAYS ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
- static void compute( logical_t const wantq, logical_t const wantz,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
@@ -186,7 +182,7 @@
         integer_t& 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,
+ tgexc_impl< value_type >::invoke( wantq, wantz, n, a, b, q, z, ifst,
             ilst, info );
     return info;
 }
@@ -198,7 +194,7 @@
         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,
+ tgexc_impl< value_type >::invoke( wantq, wantz, n, a, b, q, z, ifst,
             ilst, info, work );
     return info;
 }
@@ -211,7 +207,7 @@
         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,
+ tgexc_impl< value_type >::invoke( wantq, wantz, n, a, b, q, z, ifst,
             ilst, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -106,15 +104,14 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA,
             typename MatrixQ, typename MatrixZ, typename VectorDIF,
             typename WORK, typename IWORK >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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,
@@ -169,7 +166,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA,
             typename MatrixQ, typename MatrixZ, typename VectorDIF >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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,
@@ -179,7 +176,7 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( ijob, wantq, wantz, select, n, a, b, alphar, alphai, beta, q,
+ invoke( ijob, wantq, wantz, select, n, a, b, alphar, alphai, beta, q,
                 z, m, pl, pr, dif, info, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -187,7 +184,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA,
             typename MatrixQ, typename MatrixZ, typename VectorDIF >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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,
@@ -207,7 +204,7 @@
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( ijob, wantq, wantz, select, n, a, b, alphar, alphai, beta, q,
+ invoke( ijob, wantq, wantz, select, n, a, b, alphar, alphai, beta, q,
                 z, m, pl, pr, dif, info, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -226,15 +223,14 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHA, typename VectorBETA, typename MatrixQ,
             typename MatrixZ, typename VectorDIF, typename WORK,
             typename IWORK >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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, real_type& pl,
@@ -281,7 +277,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHA, typename VectorBETA, typename MatrixQ,
             typename MatrixZ, typename VectorDIF >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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, real_type& pl,
@@ -291,15 +287,15 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z, m,
- pl, pr, dif, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z, m, pl,
+ pr, dif, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename VectorALPHA, typename VectorBETA, typename MatrixQ,
             typename MatrixZ, typename VectorDIF >
- static void compute( integer_t const ijob, logical_t const wantq,
+ static void invoke( 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, real_type& pl,
@@ -319,8 +315,8 @@
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z, m,
- pl, pr, dif, info, workspace( tmp_work, tmp_iwork ) );
+ invoke( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z, m, pl,
+ pr, dif, info, workspace( tmp_work, tmp_iwork ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -348,7 +344,7 @@
     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,
+ tgsen_impl< value_type >::invoke( ijob, wantq, wantz, select, n, a,
             b, alphar, alphai, beta, q, z, m, pl, pr, dif, info, work );
     return info;
 }
@@ -367,7 +363,7 @@
     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,
+ tgsen_impl< value_type >::invoke( ijob, wantq, wantz, select, n, a,
             b, alphar, alphai, beta, q, z, m, pl, pr, dif, info,
             optimal_workspace() );
     return info;
@@ -385,7 +381,7 @@
     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,
+ tgsen_impl< value_type >::invoke( ijob, wantq, wantz, select, n, a,
             b, alpha, beta, q, z, m, pl, pr, dif, info, work );
     return info;
 }
@@ -403,7 +399,7 @@
     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,
+ tgsen_impl< value_type >::invoke( ijob, wantq, wantz, select, n, a,
             b, alpha, beta, q, z, m, pl, pr, dif, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -101,14 +99,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ, typename WORK >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
@@ -163,14 +160,14 @@
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
             integer_t& ncycle, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(b) ) );
- compute( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
+ invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
                 q, ncycle, info, workspace( tmp_work ) );
     }
 
@@ -178,12 +175,12 @@
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
             integer_t& ncycle, integer_t& info, optimal_workspace work ) {
- compute( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
+ invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
                 q, ncycle, info, minimal_workspace() );
     }
 
@@ -198,14 +195,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ, typename WORK >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
@@ -257,14 +253,14 @@
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
             integer_t& ncycle, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(b) ) );
- compute( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
+ invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
                 q, ncycle, info, workspace( tmp_work ) );
     }
 
@@ -272,12 +268,12 @@
     template< typename MatrixA, typename MatrixB, typename VectorALPHA,
             typename VectorBETA, typename MatrixU, typename MatrixV,
             typename MatrixQ >
- static void compute( char const jobu, char const jobv, char const jobq,
+ static void invoke( char const jobu, char const jobv, char const jobq,
             integer_t const k, integer_t const l, MatrixA& a, MatrixB& b,
             real_type const tola, real_type const tolb, VectorALPHA& alpha,
             VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
             integer_t& ncycle, integer_t& info, optimal_workspace work ) {
- compute( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
+ invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, u, v,
                 q, ncycle, info, minimal_workspace() );
     }
 
@@ -300,8 +296,8 @@
         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,
- tola, tolb, alpha, beta, u, v, q, ncycle, info, work );
+ tgsja_impl< value_type >::invoke( jobu, jobv, jobq, k, l, a, b, tola,
+ tolb, alpha, beta, u, v, q, ncycle, info, work );
     return info;
 }
 
@@ -318,9 +314,8 @@
         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() );
+ tgsja_impl< value_type >::invoke( jobu, jobv, jobq, k, l, a, b, tola,
+ tolb, alpha, beta, u, v, q, ncycle, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -92,14 +90,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF, typename WORK, typename IWORK >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
@@ -144,7 +141,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
@@ -153,7 +150,7 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
+ invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -161,7 +158,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
@@ -178,7 +175,7 @@
                 &opt_size_work, -1, traits::vector_storage(tmp_iwork), info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
+ invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -197,14 +194,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF, typename WORK, typename IWORK >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
@@ -246,7 +242,7 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
@@ -255,7 +251,7 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
+ invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -263,12 +259,12 @@
     template< typename VectorSELECT, typename MatrixA, typename MatrixB,
             typename MatrixVL, typename MatrixVR, typename VectorS,
             typename VectorDIF >
- static void compute( char const job, char const howmny,
+ static void invoke( 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, integer_t& info,
             optimal_workspace work ) {
- compute( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
+ invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -293,7 +289,7 @@
     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,
+ tgsna_impl< value_type >::invoke( job, howmny, select, n, a, b, vl,
             vr, s, dif, mm, m, info, work );
     return info;
 }
@@ -309,7 +305,7 @@
     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,
+ tgsna_impl< value_type >::invoke( job, howmny, select, n, a, b, vl,
             vr, s, dif, mm, m, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -100,14 +98,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF,
             typename WORK, typename IWORK >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, detail::workspace2< WORK,
@@ -147,21 +144,21 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( m, n ) );
- compute( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
+ invoke( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, optimal_workspace work ) {
@@ -177,7 +174,7 @@
                 traits::vector_storage(tmp_iwork), info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
+ invoke( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -196,14 +193,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF,
             typename WORK, typename IWORK >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, detail::workspace2< WORK,
@@ -243,21 +239,21 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( m, n ) );
- compute( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
+ invoke( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC,
             typename MatrixD, typename MatrixE, typename MatrixF >
- static void compute( char const trans, integer_t const ijob,
+ static void invoke( 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, real_type& scale,
             real_type& dif, integer_t& info, optimal_workspace work ) {
@@ -273,7 +269,7 @@
                 traits::vector_storage(tmp_iwork), info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
+ invoke( trans, ijob, m, n, a, b, c, d, e, f, scale, dif, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -299,7 +295,7 @@
         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,
+ tgsyl_impl< value_type >::invoke( trans, ijob, m, n, a, b, c, d, e,
             f, scale, dif, info, work );
     return info;
 }
@@ -314,7 +310,7 @@
         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,
+ tgsyl_impl< value_type >::invoke( trans, ijob, m, n, a, b, c, d, e,
             f, scale, dif, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -83,14 +81,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename IWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace2< WORK, IWORK > work ) {
@@ -131,24 +128,24 @@
     // minimal workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -167,14 +164,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename RWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
@@ -212,24 +208,24 @@
     // minimal workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixAP, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, n, ap, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -251,7 +247,7 @@
         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,
+ tprfs_impl< value_type >::invoke( uplo, trans, diag, n, ap, b, x,
             ferr, berr, info, work );
     return info;
 }
@@ -264,7 +260,7 @@
         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,
+ tprfs_impl< value_type >::invoke( uplo, trans, diag, n, ap, b, x,
             ferr, berr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAP >
- static void compute( char const diag, MatrixAP& ap, integer_t& info ) {
+ static void invoke( char const diag, MatrixAP& ap, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         BOOST_ASSERT( diag == 'N' || diag == 'U' );
@@ -77,7 +75,7 @@
 inline integer_t tptri( char const diag, MatrixAP& ap ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
- tptri_impl< value_type >::compute( diag, ap, info );
+ tptri_impl< value_type >::invoke( diag, ap, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -62,12 +60,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixAP, typename MatrixB >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             integer_t const n, MatrixAP& ap, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
@@ -91,8 +88,7 @@
         char const diag, integer_t const n, MatrixAP& ap, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
     integer_t info(0);
- tptrs_impl< value_type >::compute( uplo, trans, diag, n, ap, b,
- info );
+ tptrs_impl< value_type >::invoke( uplo, trans, diag, n, ap, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename IWORK >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info, detail::workspace2<
             WORK, IWORK > work ) {
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -100,23 +98,23 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( norm, uplo, diag, a, rcond, info, workspace( tmp_work,
+ invoke( norm, uplo, diag, a, rcond, info, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info,
             optimal_workspace work ) {
- compute( norm, uplo, diag, a, rcond, info, minimal_workspace() );
+ invoke( norm, uplo, diag, a, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -134,11 +132,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename WORK, typename RWORK >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info, detail::workspace2<
             WORK, RWORK > work ) {
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -159,23 +157,23 @@
 
     // minimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( norm, uplo, diag, a, rcond, info, workspace( tmp_work,
+ invoke( norm, uplo, diag, a, rcond, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA >
- static void compute( char const norm, char const uplo, char const diag,
+ static void invoke( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info,
             optimal_workspace work ) {
- compute( norm, uplo, diag, a, rcond, info, minimal_workspace() );
+ invoke( norm, uplo, diag, a, rcond, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -195,7 +193,7 @@
         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,
+ trcon_impl< value_type >::invoke( norm, uplo, diag, a, rcond, info,
             work );
     return info;
 }
@@ -207,7 +205,7 @@
         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,
+ trcon_impl< value_type >::invoke( norm, uplo, diag, a, rcond, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -83,12 +81,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename WORK >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             detail::workspace1< WORK > work ) {
@@ -117,24 +115,24 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(t) ) );
- compute( side, howmny, select, t, vl, vr, mm, m, info,
+ invoke( side, howmny, select, t, vl, vr, mm, m, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             optimal_workspace work ) {
- compute( side, howmny, select, t, vl, vr, mm, m, info,
+ invoke( side, howmny, select, t, vl, vr, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -149,12 +147,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename WORK, typename RWORK >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
@@ -186,7 +184,7 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             minimal_workspace work ) {
@@ -194,18 +192,18 @@
                 traits::matrix_num_columns(t) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(t) ) );
- compute( side, howmny, select, t, vl, vr, mm, m, info,
+ invoke( side, howmny, select, t, vl, vr, mm, m, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const side, char const howmny,
+ static void invoke( char const side, char const howmny,
             VectorSELECT& select, MatrixT& t, MatrixVL& vl, MatrixVR& vr,
             integer_t const mm, integer_t& m, integer_t& info,
             optimal_workspace work ) {
- compute( side, howmny, select, t, vl, vr, mm, m, info,
+ invoke( side, howmny, select, t, vl, vr, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -228,7 +226,7 @@
     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,
+ trevc_impl< value_type >::invoke( side, howmny, select, t, vl, vr,
             mm, m, info, work );
     return info;
 }
@@ -242,7 +240,7 @@
     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,
+ trevc_impl< value_type >::invoke( side, howmny, select, t, vl, vr,
             mm, m, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -75,11 +73,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixT, typename MatrixQ >
- static void compute( char const compq, MatrixT& t, MatrixQ& q,
+ static void invoke( char const compq, MatrixT& t, MatrixQ& q,
             integer_t& ifst, integer_t& ilst, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
@@ -105,11 +103,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixT, typename MatrixQ, $WORKSPACE_TYPENAMES >
- static void compute( char const compq, MatrixT& t, MatrixQ& q,
+ static void invoke( char const compq, MatrixT& t, MatrixQ& q,
             integer_t const ifst, integer_t const ilst, integer_t& info,
             detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -129,16 +127,16 @@
 
     // minimal workspace specialization
     template< typename MatrixT, typename MatrixQ >
- static void compute( char const compq, MatrixT& t, MatrixQ& q,
+ static void invoke( char const compq, MatrixT& t, MatrixQ& q,
             integer_t const ifst, integer_t const ilst, integer_t& info,
             minimal_workspace work ) {
 $SETUP_MIN_WORKARRAYS_POST
- compute( compq, t, q, ifst, ilst, info, workspace( $TMP_WORKARRAYS ) );
+ invoke( compq, t, q, ifst, ilst, info, workspace( $TMP_WORKARRAYS ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixT, typename MatrixQ >
- static void compute( char const compq, MatrixT& t, MatrixQ& q,
+ static void invoke( char const compq, MatrixT& t, MatrixQ& q,
             integer_t const ifst, integer_t const ilst, integer_t& info,
             optimal_workspace work ) {
 $OPT_WORKSPACE_FUNC
@@ -154,7 +152,7 @@
         integer_t& ifst, integer_t& 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 );
+ trexc_impl< value_type >::invoke( compq, t, q, ifst, ilst, info );
     return info;
 }
 // template function to call trexc
@@ -163,7 +161,7 @@
         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,
+ trexc_impl< value_type >::invoke( compq, t, q, ifst, ilst, info,
             work );
     return info;
 }
@@ -174,7 +172,7 @@
         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,
+ trexc_impl< value_type >::invoke( compq, t, q, ifst, ilst, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,14 +85,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename IWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
@@ -140,24 +137,24 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, trans, diag, a, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, a, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( uplo, trans, diag, a, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, a, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -176,14 +173,13 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename RWORK >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
@@ -226,24 +222,24 @@
     // minimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( uplo, trans, diag, a, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, a, b, x, ferr, berr, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, MatrixX& x, VectorFERR& ferr,
             VectorBERR& berr, integer_t& info, optimal_workspace work ) {
- compute( uplo, trans, diag, a, b, x, ferr, berr, info,
+ invoke( uplo, trans, diag, a, b, x, ferr, berr, info,
                 minimal_workspace() );
     }
 
@@ -265,7 +261,7 @@
         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,
+ trrfs_impl< value_type >::invoke( uplo, trans, diag, a, b, x, ferr,
             berr, info, work );
     return info;
 }
@@ -278,7 +274,7 @@
         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,
+ trrfs_impl< value_type >::invoke( uplo, trans, diag, a, b, x, ferr,
             berr, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixQ,
             typename VectorW, typename WORK >
- static void compute( char const job, char const compq,
+ static void invoke( char const job, char const compq,
             VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
             integer_t& m, real_type& s, real_type& sep, integer_t& info,
             detail::workspace1< WORK > work ) {
@@ -98,20 +96,20 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixQ,
             typename VectorW >
- static void compute( char const job, char const compq,
+ static void invoke( char const job, char const compq,
             VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
             integer_t& m, real_type& s, real_type& sep, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( job, compq, select, t, q, w, m, s, sep, info,
+ invoke( job, compq, select, t, q, w, m, s, sep, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixQ,
             typename VectorW >
- static void compute( char const job, char const compq,
+ static void invoke( char const job, char const compq,
             VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
             integer_t& m, real_type& s, real_type& sep, integer_t& info,
             optimal_workspace work ) {
@@ -123,7 +121,7 @@
                 sep, &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( job, compq, select, t, q, w, m, s, sep, info,
+ invoke( job, compq, select, t, q, w, m, s, sep, info,
                 workspace( tmp_work ) );
     }
 
@@ -144,7 +142,7 @@
     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,
+ trsen_impl< value_type >::invoke( job, compq, select, t, q, w, m, s,
             sep, info, work );
     return info;
 }
@@ -160,7 +158,7 @@
     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,
+ trsen_impl< value_type >::invoke( job, compq, select, t, q, w, m, s,
             sep, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -88,13 +86,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP,
             typename WORK, typename IWORK >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
@@ -133,7 +131,7 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, minimal_workspace work ) {
@@ -141,18 +139,18 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
                 $CALL_MIN_SIZE ) );
- compute( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
+ invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
                 workspace( tmp_work, tmp_iwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, optimal_workspace work ) {
- compute( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
+ invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -171,13 +169,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP,
             typename WORK, typename RWORK >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
@@ -213,7 +211,7 @@
     // minimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, minimal_workspace work ) {
@@ -221,18 +219,18 @@
                 $CALL_MIN_SIZE ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 $CALL_MIN_SIZE ) );
- compute( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
+ invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename VectorSELECT, typename MatrixT, typename MatrixVL,
             typename MatrixVR, typename VectorS, typename VectorSEP >
- static void compute( char const job, char const howmny,
+ static void invoke( 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,
             integer_t& info, optimal_workspace work ) {
- compute( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
+ invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, info,
                 minimal_workspace() );
     }
 
@@ -257,7 +255,7 @@
     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,
+ trsna_impl< value_type >::invoke( job, howmny, select, t, vl, vr, s,
             sep, mm, m, info, work );
     return info;
 }
@@ -271,7 +269,7 @@
     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,
+ trsna_impl< value_type >::invoke( job, howmny, select, t, vl, vr, s,
             sep, mm, m, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -79,12 +77,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC >
- static void compute( char const trana, char const tranb,
+ static void invoke( char const trana, char const tranb,
             integer_t const isgn, integer_t const m, integer_t const n,
             MatrixA& a, MatrixB& b, MatrixC& c, real_type& scale,
             integer_t& info ) {
@@ -114,12 +111,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB, typename MatrixC >
- static void compute( char const trana, char const tranb,
+ static void invoke( char const trana, char const tranb,
             integer_t const isgn, integer_t const m, integer_t const n,
             MatrixA& a, MatrixB& b, MatrixC& c, real_type& scale,
             integer_t& info ) {
@@ -152,7 +148,7 @@
         MatrixA >::value_type& scale ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- trsyl_impl< value_type >::compute( trana, tranb, isgn, m, n, a, b, c,
+ trsyl_impl< value_type >::invoke( trana, tranb, isgn, m, n, a, b, c,
             scale, info );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -56,11 +54,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA >
- static void compute( char const diag, MatrixA& a, integer_t& info ) {
+ static void invoke( char const diag, MatrixA& a, integer_t& info ) {
         BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
         BOOST_ASSERT( diag == 'N' || diag == 'U' );
@@ -79,7 +77,7 @@
 inline integer_t trtri( char const diag, MatrixA& a ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- trtri_impl< value_type >::compute( diag, a, info );
+ trtri_impl< value_type >::invoke( diag, a, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -70,12 +68,11 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // templated specialization
     template< typename MatrixA, typename MatrixB >
- static void compute( char const uplo, char const trans, char const diag,
+ static void invoke( char const uplo, char const trans, char const diag,
             MatrixA& a, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
@@ -103,7 +100,7 @@
         char const diag, MatrixA& a, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
     integer_t info(0);
- trtrs_impl< value_type >::compute( uplo, trans, diag, a, b, info );
+ trtrs_impl< value_type >::invoke( uplo, trans, diag, a, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -74,11 +72,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -100,16 +98,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         real_type opt_size_work;
         detail::tzrzf( traits::matrix_num_rows(a),
@@ -118,7 +116,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -132,11 +130,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -158,16 +156,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( MatrixA& a, VectorTAU& tau, integer_t& info,
+ static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
         detail::tzrzf( traits::matrix_num_rows(a),
@@ -176,7 +174,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( a, tau, info, workspace( tmp_work ) );
+ invoke( a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -190,7 +188,7 @@
 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 );
+ tzrzf_impl< value_type >::invoke( a, tau, info, work );
     return info;
 }
 
@@ -199,8 +197,7 @@
 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() );
+ tzrzf_impl< value_type >::invoke( a, tau, info, optimal_workspace() );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,13 +57,13 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, detail::workspace1< WORK > work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
@@ -83,25 +81,25 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, minimal_workspace work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( m, n ) );
- compute( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( char const vect, integer_t const m,
- integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau,
- integer_t& info, optimal_workspace work ) {
+ static void invoke( char const vect, integer_t const m, integer_t const n,
+ integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
+ optimal_workspace work ) {
         value_type opt_size_work;
         detail::ungbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m, integer_t const n ) {
@@ -117,8 +115,7 @@
         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,
- work );
+ ungbr_impl< value_type >::invoke( vect, m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -128,7 +125,7 @@
         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,
+ ungbr_impl< value_type >::invoke( vect, m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,11 +57,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -82,17 +80,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, integer_t const ilo,
+ static void invoke( integer_t const n, integer_t const ilo,
             integer_t const ihi, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -101,7 +99,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
+ invoke( n, ilo, ihi, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -116,7 +114,7 @@
         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 );
+ unghr_impl< value_type >::invoke( n, ilo, ihi, a, tau, info, work );
     return info;
 }
 
@@ -126,7 +124,7 @@
         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,
+ unghr_impl< value_type >::invoke( n, ilo, ihi, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,11 +57,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -84,16 +82,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( m ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -102,7 +100,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -117,7 +115,7 @@
         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 );
+ unglq_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
         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,
+ unglq_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,11 +57,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -84,16 +82,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -102,7 +100,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -117,7 +115,7 @@
         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 );
+ ungql_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
         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,
+ ungql_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,11 +57,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -84,16 +82,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -102,7 +100,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -117,7 +115,7 @@
         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 );
+ ungqr_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
         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,
+ ungqr_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -59,11 +57,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -84,16 +82,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( m ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const m, integer_t const n,
+ static void invoke( integer_t const m, integer_t const n,
             integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -102,7 +100,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( m, n, k, a, tau, info, workspace( tmp_work ) );
+ invoke( m, n, k, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const m ) {
@@ -117,7 +115,7 @@
         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 );
+ ungrq_impl< value_type >::invoke( m, n, k, a, tau, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
         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,
+ ungrq_impl< value_type >::invoke( m, n, k, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -57,11 +55,11 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename WORK >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
@@ -82,16 +80,16 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side, m,
                 n ) );
- compute( n, a, tau, info, workspace( tmp_work ) );
+ invoke( n, a, tau, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU >
- static void compute( integer_t const n, MatrixA& a, VectorTAU& tau,
+ static void invoke( integer_t const n, MatrixA& a, VectorTAU& tau,
             integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
         detail::ungtr( traits::matrix_uplo_tag(a), n,
@@ -99,7 +97,7 @@
                 traits::vector_storage(tau), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( n, a, tau, info, workspace( tmp_work ) );
+ invoke( n, a, tau, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( integer_t const side, integer_t const m,
@@ -118,7 +116,7 @@
         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 );
+ ungtr_impl< value_type >::invoke( n, a, tau, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
 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,
+ ungtr_impl< value_type >::invoke( n, a, tau, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -63,12 +61,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -99,18 +97,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( vect, side, trans, k, a, tau, c, info,
- workspace( tmp_work ) );
+ invoke( vect, side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const vect, char const side, char const trans,
+ static void invoke( char const vect, char const side, char const trans,
             integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c,
             integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
@@ -121,8 +118,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( vect, side, trans, k, a, tau, c, info,
- workspace( tmp_work ) );
+ invoke( vect, side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -143,7 +139,7 @@
         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,
+ unmbr_impl< value_type >::invoke( vect, side, trans, k, a, tau, c,
             info, work );
     return info;
 }
@@ -155,7 +151,7 @@
         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,
+ unmbr_impl< value_type >::invoke( vect, side, trans, k, a, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -63,12 +61,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info, detail::workspace1<
             WORK > work ) {
@@ -98,19 +96,19 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, ilo, ihi, a, tau, c, info,
+ invoke( side, trans, ilo, ihi, a, tau, c, info,
                 workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans,
+ static void invoke( char const side, char const trans,
             integer_t const ilo, integer_t const ihi, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
@@ -122,7 +120,7 @@
                 traits::leading_dimension(c), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, ilo, ihi, a, tau, c, info,
+ invoke( side, trans, ilo, ihi, a, tau, c, info,
                 workspace( tmp_work ) );
     }
 
@@ -144,7 +142,7 @@
         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,
+ unmhr_impl< value_type >::invoke( side, trans, ilo, ihi, a, tau, c,
             info, work );
     return info;
 }
@@ -156,7 +154,7 @@
         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,
+ unmhr_impl< value_type >::invoke( side, trans, ilo, ihi, a, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -96,17 +94,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -117,7 +115,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -138,7 +136,7 @@
         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,
+ unmlq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -149,7 +147,7 @@
         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,
+ unmlq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -95,17 +93,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -116,7 +114,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -137,7 +135,7 @@
         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,
+ unmql_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -148,7 +146,7 @@
         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,
+ unmql_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -95,17 +93,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -116,7 +114,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -137,7 +135,7 @@
         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,
+ unmqr_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -148,7 +146,7 @@
         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,
+ unmqr_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -96,17 +94,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -117,7 +115,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -138,7 +136,7 @@
         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,
+ unmrq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -149,7 +147,7 @@
         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,
+ unmrq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -96,17 +94,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, integer_t const k,
+ static void invoke( char const side, char const trans, integer_t const k,
             MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -118,7 +116,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, k, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -135,7 +133,7 @@
         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,
+ unmrz_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             work );
     return info;
 }
@@ -146,7 +144,7 @@
         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,
+ unmrz_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -61,12 +59,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info, detail::workspace1<
             WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -97,17 +95,17 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( side,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) );
- compute( side, trans, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, a, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const trans, MatrixA& a,
+ static void invoke( char const side, char const trans, MatrixA& a,
             VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
         value_type opt_size_work;
@@ -118,7 +116,7 @@
                 traits::leading_dimension(c), &opt_size_work, -1, info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( side, trans, a, tau, c, info, workspace( tmp_work ) );
+ invoke( side, trans, a, tau, c, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const side, integer_t const m,
@@ -138,7 +136,7 @@
         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,
+ unmtr_impl< value_type >::invoke( side, trans, a, tau, c, info,
             work );
     return info;
 }
@@ -149,7 +147,7 @@
         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,
+ unmtr_impl< value_type >::invoke( side, trans, a, tau, c, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ,
             typename WORK >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::vector_traits<
@@ -90,18 +88,18 @@
 
     // minimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(q) ) );
- compute( uplo, ap, tau, q, info, workspace( tmp_work ) );
+ invoke( uplo, ap, tau, q, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
- static void compute( char const uplo, VectorAP& ap, VectorTAU& tau,
+ static void invoke( char const uplo, VectorAP& ap, VectorTAU& tau,
             MatrixQ& q, integer_t& info, optimal_workspace work ) {
- compute( uplo, ap, tau, q, info, minimal_workspace() );
+ invoke( uplo, ap, tau, q, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( integer_t const n ) {
@@ -117,7 +115,7 @@
         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 );
+ upgtr_impl< value_type >::invoke( uplo, ap, tau, q, info, work );
     return info;
 }
 
@@ -127,7 +125,7 @@
         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,
+ upgtr_impl< value_type >::invoke( uplo, ap, tau, q, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -58,12 +56,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC,
             typename WORK >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
@@ -90,20 +88,20 @@
 
     // minimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- compute( side, uplo, trans, ap, tau, c, info, workspace( tmp_work ) );
+ invoke( side, uplo, trans, ap, tau, c, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename VectorAP, typename VectorTAU, typename MatrixC >
- static void compute( char const side, char const uplo, char const trans,
+ static void invoke( char const side, char const uplo, char const trans,
             VectorAP& ap, VectorTAU& tau, MatrixC& c, integer_t& info,
             optimal_workspace work ) {
- compute( side, uplo, trans, ap, tau, c, info, minimal_workspace() );
+ invoke( side, uplo, trans, ap, tau, c, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -120,7 +118,7 @@
         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,
+ upmtr_impl< value_type >::invoke( side, uplo, trans, ap, tau, c,
             info, work );
     return info;
 }
@@ -131,7 +129,7 @@
         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,
+ upmtr_impl< value_type >::invoke( side, uplo, trans, ap, tau, c,
             info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -52,13 +50,12 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
             typename MatrixX, typename WORK, typename SWORK >
- static void compute( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
             integer_t& iter, integer_t& info, detail::workspace2< WORK,
             SWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -95,22 +92,22 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
             typename MatrixX >
- static void compute( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
             integer_t& iter, integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         traits::detail::array< value_type > tmp_swork( min_size_swork(
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ) );
- compute( a, ipiv, b, x, iter, info, workspace( tmp_work, tmp_swork ) );
+ invoke( a, ipiv, b, x, iter, info, workspace( tmp_work, tmp_swork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorIPIV, typename MatrixB,
             typename MatrixX >
- static void compute( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
+ static void invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, MatrixX& x,
             integer_t& iter, integer_t& info, optimal_workspace work ) {
- compute( a, ipiv, b, x, iter, info, minimal_workspace() );
+ invoke( a, ipiv, b, x, iter, info, minimal_workspace() );
     }
 
     static integer_t min_size_work( $ARGUMENTS ) {
@@ -131,7 +128,7 @@
         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 );
+ cgesv_impl< value_type >::invoke( a, ipiv, b, x, iter, info, work );
     return info;
 }
 
@@ -142,7 +139,7 @@
         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,
+ cgesv_impl< value_type >::invoke( a, ipiv, b, x, iter, info,
             optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -66,12 +64,17 @@
 
     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;
+
+ // uniform high-level dispatching-function
+ template< typename MatrixA, typename MatrixB, typename VectorP >
+ static void solve( MatrixA& A, MatrixB& B, VectorP& pivot,
+ integer_t& info ) {
+ invoke( A, pivot, B, info );
+ }
 
     // templated specialization
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
- static void compute( integer_t const kl, integer_t const ku, MatrixAB& ab,
+ static void invoke( integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, MatrixB& b, integer_t& info ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
@@ -100,7 +103,7 @@
         MatrixAB& ab, VectorIPIV& ipiv, MatrixB& b ) {
     typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
     integer_t info(0);
- gbsv_impl< value_type >::compute( kl, ku, ab, ipiv, b, info );
+ gbsv_impl< value_type >::invoke( kl, ku, ab, ipiv, b, info );
     return info;
 }
 

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -99,15 +97,14 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename IWORK >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
@@ -169,7 +166,7 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
@@ -177,7 +174,7 @@
             minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( n ) );
         traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) );
- compute( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
+ invoke( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
                 rcond, ferr, berr, info, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -185,13 +182,13 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
+ invoke( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
                 rcond, ferr, berr, info, minimal_workspace() );
     }
 
@@ -210,15 +207,14 @@
 
     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;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename RWORK >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
@@ -277,7 +273,7 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
@@ -285,7 +281,7 @@
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work( n ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- compute( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
+ invoke( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
                 rcond, ferr, berr, info, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -293,13 +289,13 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename VectorR, typename VectorC, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static void compute( char const fact, char const trans, integer_t const n,
+ static void invoke( 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, real_type& rcond,
             VectorFERR& ferr, VectorBERR& berr, integer_t& info,
             optimal_workspace work ) {
- compute( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
+ invoke( fact, trans, n, kl, ku, ab, afb, ipiv, equed, r, c, b, x,
                 rcond, ferr, berr, info, minimal_workspace() );
     }
 
@@ -326,7 +322,7 @@
         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,
+ gbsvx_impl< value_type >::invoke( fact, trans, n, kl, ku, ab, afb,
             ipiv, equed, r, c, b, x, rcond, ferr, berr, info, work );
     return info;
 }
@@ -343,7 +339,7 @@
         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,
+ gbsvx_impl< value_type >::invoke( fact, trans, n, kl, ku, ab, afb,
             ipiv, equed, r, c, b, x, rcond, ferr, berr, info,
             optimal_workspace() );
     return info;

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -88,12 +86,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS, typename WORK, typename BWORK >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorWR& wr, VectorWI& wi,
             MatrixVS& vs, integer_t& info, detail::workspace2< WORK,
             BWORK > work ) {
@@ -131,21 +129,21 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorWR& wr, VectorWI& wi,
             MatrixVS& vs, integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< bool > tmp_bwork( min_size_bwork(
                 traits::matrix_num_columns(a), sort ) );
- compute( jobvs, sort, select, a, sdim, wr, wi, vs, info,
+ invoke( jobvs, sort, select, a, sdim, wr, wi, vs, info,
                 workspace( tmp_work, tmp_bwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorWR& wr, VectorWI& wi,
             MatrixVS& vs, integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
@@ -159,7 +157,7 @@
                 &opt_size_work, -1, traits::vector_storage(tmp_bwork), info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( jobvs, sort, select, a, sdim, wr, wi, vs, info,
+ invoke( jobvs, sort, select, a, sdim, wr, wi, vs, info,
                 workspace( tmp_work, tmp_bwork ) );
     }
 
@@ -181,12 +179,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS,
             typename WORK, typename RWORK, typename BWORK >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorW& w, MatrixVS& vs,
             integer_t& info, detail::workspace3< WORK, RWORK, BWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -220,7 +218,7 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorW& w, MatrixVS& vs,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
@@ -229,13 +227,13 @@
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< bool > tmp_bwork( min_size_bwork(
                 traits::matrix_num_columns(a), sort ) );
- compute( jobvs, sort, select, a, sdim, w, vs, info,
+ invoke( jobvs, sort, select, a, sdim, w, vs, info,
                 workspace( tmp_work, tmp_rwork, tmp_bwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             MatrixA& a, integer_t& sdim, VectorW& w, MatrixVS& vs,
             integer_t& info, optimal_workspace work ) {
         value_type opt_size_work;
@@ -251,7 +249,7 @@
                 traits::vector_storage(tmp_bwork), info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( jobvs, sort, select, a, sdim, w, vs, info,
+ invoke( jobvs, sort, select, a, sdim, w, vs, info,
                 workspace( tmp_work, tmp_rwork, tmp_bwork ) );
     }
 
@@ -280,7 +278,7 @@
         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,
+ gees_impl< value_type >::invoke( jobvs, sort, select, a, sdim, wr,
             wi, vs, info, work );
     return info;
 }
@@ -293,7 +291,7 @@
         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,
+ gees_impl< value_type >::invoke( jobvs, sort, select, a, sdim, wr,
             wi, vs, info, optimal_workspace() );
     return info;
 }
@@ -305,7 +303,7 @@
         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,
+ gees_impl< value_type >::invoke( jobvs, sort, select, a, sdim, w,
             vs, info, work );
     return info;
 }
@@ -317,7 +315,7 @@
         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,
+ gees_impl< value_type >::invoke( jobvs, sort, select, a, sdim, w,
             vs, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -92,12 +90,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS, typename WORK, typename IWORK, typename BWORK >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorWR& wr,
             VectorWI& wi, MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, detail::workspace3< WORK, IWORK, BWORK > work ) {
@@ -143,7 +141,7 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorWR& wr,
             VectorWI& wi, MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, minimal_workspace work ) {
@@ -153,14 +151,14 @@
                 traits::matrix_num_columns(a), sense ) );
         traits::detail::array< bool > tmp_bwork( min_size_bwork(
                 traits::matrix_num_columns(a), sort ) );
- compute( jobvs, sort, select, sense, a, sdim, wr, wi, vs, rconde,
+ invoke( jobvs, sort, select, sense, a, sdim, wr, wi, vs, rconde,
                 rcondv, info, workspace( tmp_work, tmp_iwork, tmp_bwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorWR& wr,
             VectorWI& wi, MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, optimal_workspace work ) {
@@ -178,7 +176,7 @@
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         traits::detail::array< integer_t > tmp_iwork( opt_size_iwork );
- compute( jobvs, sort, select, sense, a, sdim, wr, wi, vs, rconde,
+ invoke( jobvs, sort, select, sense, a, sdim, wr, wi, vs, rconde,
                 rcondv, info, workspace( tmp_work, tmp_iwork, tmp_bwork ) );
     }
 
@@ -210,12 +208,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS,
             typename WORK, typename RWORK, typename BWORK >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorW& w,
             MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, detail::workspace3< WORK, RWORK, BWORK > work ) {
@@ -253,7 +251,7 @@
 
     // minimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorW& w,
             MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, minimal_workspace work ) {
@@ -263,13 +261,13 @@
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< bool > tmp_bwork( min_size_bwork(
                 traits::matrix_num_columns(a), sort ) );
- compute( jobvs, sort, select, sense, a, sdim, w, vs, rconde, rcondv,
+ invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde, rcondv,
                 info, workspace( tmp_work, tmp_rwork, tmp_bwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVS >
- static void compute( char const jobvs, char const sort, logical_t* select,
+ static void invoke( char const jobvs, char const sort, logical_t* select,
             char const sense, MatrixA& a, integer_t& sdim, VectorW& w,
             MatrixVS& vs, real_type& rconde, real_type& rcondv,
             integer_t& info, optimal_workspace work ) {
@@ -287,7 +285,7 @@
                 traits::vector_storage(tmp_bwork), info );
         traits::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( jobvs, sort, select, sense, a, sdim, w, vs, rconde, rcondv,
+ invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde, rcondv,
                 info, workspace( tmp_work, tmp_rwork, tmp_bwork ) );
     }
 
@@ -322,7 +320,7 @@
         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,
+ geesx_impl< value_type >::invoke( jobvs, sort, select, sense, a,
             sdim, wr, wi, vs, rconde, rcondv, info, work );
     return info;
 }
@@ -337,7 +335,7 @@
         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,
+ geesx_impl< value_type >::invoke( jobvs, sort, select, sense, a,
             sdim, wr, wi, vs, rconde, rcondv, info, optimal_workspace() );
     return info;
 }
@@ -351,7 +349,7 @@
         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,
+ geesx_impl< value_type >::invoke( jobvs, sort, select, sense, a,
             sdim, w, vs, rconde, rcondv, info, work );
     return info;
 }
@@ -365,7 +363,7 @@
         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,
+ geesx_impl< value_type >::invoke( jobvs, sort, select, sense, a,
             sdim, w, vs, rconde, rcondv, info, optimal_workspace() );
     return info;
 }

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-20 12:43:05 EDT (Fri, 20 Mar 2009)
@@ -15,9 +15,7 @@
 #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>
@@ -87,12 +85,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVL, typename MatrixVR, typename WORK >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
             VectorWR& wr, VectorWI& wi, MatrixVL& vl, MatrixVR& vr,
             integer_t& info, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -130,19 +128,18 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
             VectorWR& wr, VectorWI& wi, MatrixVL& vl, MatrixVR& vr,
             integer_t& info, minimal_workspace work ) {
         traits::detail::array< real_type > tmp_work( min_size_work( jobvl,
                 jobvr, traits::matrix_num_columns(a) ) );
- compute( jobvl, jobvr, a, wr, wi, vl, vr, info,
- workspace( tmp_work ) );
+ invoke( jobvl, jobvr, a, wr, wi, vl, vr, info, workspace( tmp_work ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorWR, typename VectorWI,
             typename MatrixVL, typename MatrixVR >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
             VectorWR& wr, VectorWI& wi, MatrixVL& vl, MatrixVR& vr,
             integer_t& info, optimal_workspace work ) {
         real_type opt_size_work;
@@ -154,8 +151,7 @@
                 &opt_size_work, -1, info );
         traits::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- compute( jobvl, jobvr, a, wr, wi, vl, vr, info,
- workspace( tmp_work ) );
+ invoke( jobvl, jobvr, a, wr, wi, vl, vr, info, workspace( tmp_work ) );
     }
 
     static integer_t min_size_work( char const jobvl, char const jobvr,
@@ -173,12 +169,12 @@
 
     typedef ValueType value_type;
     typedef typename traits::type_traits<ValueType>::real_type real_type;
- typedef typename mpl::vector< keywords::tag::A > valid_keywords;
 
+$INCLUDE_TEMPLATES
     // user-defined workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVL,
             typename MatrixVR, typename WORK, typename RWORK >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
             VectorW& w, MatrixVL& vl, MatrixVR& vr, integer_t& info,
             detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
@@ -214,21 +210,21 @@
     // minimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
             VectorW& w, MatrixVL& vl, MatrixVR& vr, integer_t& info,
             minimal_workspace work ) {
         traits::detail::array< value_type > tmp_work( min_size_work(
                 traits::matrix_num_columns(a) ) );
         traits::detail::array< real_type > tmp_rwork( min_size_rwork(
                 traits::matrix_num_columns(a) ) );
- compute( jobvl, jobvr, a, w, vl, vr, info, workspace( tmp_work,
+ invoke( jobvl, jobvr, a, w, vl, vr, info, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
     // optimal workspace specialization
     template< typename MatrixA, typename VectorW, typename MatrixVL,
             typename MatrixVR >
- static void compute( char const jobvl, char const jobvr, MatrixA& a,
+ static void invoke( char const jobvl, char const jobvr, MatrixA& a,
 &n