Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r58998 - in sandbox/numeric_bindings/boost/numeric/bindings: blas/level1 blas/level2 blas/level3 glas glas/detail lapack/auxiliary lapack/computational lapack/driver
From: rutger_at_[hidden]
Date: 2010-01-14 07:12:36


Author: rutger
Date: 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
New Revision: 58998
URL: http://svn.boost.org/trac/boost/changeset/58998

Log:
Initial support for glas dense_vector and dense_matrix containers. Required explicit namespaces for free functions of the bindings in the blas/lapack bindings.

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

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -135,7 +135,9 @@
     //
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
- return detail::asum( size(x), begin_value(x), stride(x) );
+ namespace bindings = ::boost::numeric::bindings;
+ return detail::asum( bindings::size(x),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -206,12 +206,14 @@
     template< typename VectorX, typename VectorY >
     static return_type invoke( const value_type a, const VectorX& x,
             VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::axpy( size(x), a, begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::axpy( bindings::size(x), a, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -201,12 +201,14 @@
     //
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::copy( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::copy( bindings::size(x), bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -139,11 +139,13 @@
     //
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- return detail::dot( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ return detail::dot( bindings::size(x),
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,11 +145,13 @@
     //
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- return detail::dotc( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ return detail::dotc( bindings::size(x),
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,11 +145,13 @@
     //
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, const VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- return detail::dotu( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ return detail::dotu( bindings::size(x),
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -135,7 +135,9 @@
     //
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
- return detail::nrm2( size(x), begin_value(x), stride(x) );
+ namespace bindings = ::boost::numeric::bindings;
+ return detail::nrm2( bindings::size(x),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -142,12 +142,14 @@
     template< typename VectorX, typename VectorY >
     static return_type invoke( const VectorX& x, VectorY& y,
             const real_type c, const real_type s ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::rot( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y), c, s );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::rot( bindings::size(x), bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), c, s );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,6 +133,7 @@
     //
     static return_type invoke( real_type& a, real_type& b, real_type& c,
             real_type& s ) {
+ namespace bindings = ::boost::numeric::bindings;
         detail::rotg( a, b, c, s );
     }
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -141,17 +141,18 @@
     static return_type invoke( const std::ptrdiff_t n, VectorX& x,
             const std::ptrdiff_t incx, VectorY& y,
             const std::ptrdiff_t incy, VectorPARAM& param ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorPARAM >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorPARAM >::value) );
- detail::rotm( n, begin_value(x), incx, begin_value(y), incy,
- begin_value(param) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorPARAM >::value) );
+ detail::rotm( n, bindings::begin_value(x), incx,
+ bindings::begin_value(y), incy, bindings::begin_value(param) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,8 +140,9 @@
     template< typename VectorDPARAM >
     static return_type invoke( real_type& d1, real_type& d2, real_type& x1,
             const real_type y1, VectorDPARAM& dparam ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorDPARAM >::value) );
- detail::rotmg( d1, d2, x1, y1, begin_value(dparam) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDPARAM >::value) );
+ detail::rotmg( d1, d2, x1, y1, bindings::begin_value(dparam) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -195,8 +195,10 @@
     //
     template< typename VectorX >
     static return_type invoke( const value_type a, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- detail::scal( size(x), a, begin_value(x), stride(x) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ detail::scal( bindings::size(x), a, bindings::begin_value(x),
+ bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -111,11 +111,12 @@
     static return_type invoke( const std::ptrdiff_t n, const VectorSX& sx,
             const std::ptrdiff_t incx, const VectorSY& sy,
             const std::ptrdiff_t incy ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorSX >::type >::type, typename remove_const<
                 typename value< VectorSY >::type >::type >::value) );
- return detail::sdot( n, begin_value(sx), incx, begin_value(sy),
- incy );
+ return detail::sdot( n, bindings::begin_value(sx), incx,
+ bindings::begin_value(sy), incy );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -201,13 +201,15 @@
     //
     template< typename VectorX, typename VectorY >
     static return_type invoke( VectorX& x, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::swap( size(x), begin_value(x), stride(x),
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::swap( bindings::size(x), bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -271,6 +271,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -279,13 +280,16 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::gbmv( order(), trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), bandwidth_lower_op(a, trans()),
- bandwidth_upper_op(a, trans()), alpha, begin_value(a),
- stride_major(a), begin_value(x), stride(x), beta,
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::gbmv( order(), trans(), bindings::size_row_op(a,
+ trans()), bindings::size_column_op(a, trans()),
+ bindings::bandwidth_lower_op(a, trans()),
+ bindings::bandwidth_upper_op(a, trans()), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x), beta,
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -267,6 +267,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -275,12 +276,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::gemv( order(), trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), alpha, begin_value(a),
- stride_major(a), begin_value(x), stride(x), beta,
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::gemv( order(), trans(), bindings::size_row_op(a,
+ trans()), bindings::size_column_op(a, trans()), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x), beta,
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -161,6 +161,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
@@ -168,11 +169,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::ger( order(), size_row(a), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::ger( order(), bindings::size_row(a),
+ bindings::size_column(a), alpha, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), bindings::begin_value(a),
+ bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -167,6 +167,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
@@ -174,11 +175,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::gerc( order(), size_row(a), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::gerc( order(), bindings::size_row(a),
+ bindings::size_column(a), alpha, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), bindings::begin_value(a),
+ bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -167,6 +167,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
@@ -174,11 +175,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::geru( order(), size_row(a), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::geru( order(), bindings::size_row(a),
+ bindings::size_column(a), alpha, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), bindings::begin_value(a),
+ bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -176,6 +176,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -184,11 +185,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::hbmv( order(), uplo(), size_column(a),
- bandwidth_upper(a), alpha, begin_value(a), stride_major(a),
- begin_value(x), stride(x), beta, begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::hbmv( order(), uplo(), bindings::size_column(a),
+ bindings::bandwidth_upper(a), alpha, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(x),
+ bindings::stride(x), beta, bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -175,6 +175,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -183,11 +184,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::hemv( order(), uplo(), size_column(a), alpha,
- begin_value(a), stride_major(a), begin_value(x), stride(x),
- beta, begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::hemv( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x), beta,
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -160,15 +160,18 @@
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::her( order(), uplo(), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::her( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -171,6 +171,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -179,11 +180,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::her2( order(), uplo(), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::her2( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -171,6 +171,7 @@
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixAP& ap,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -179,10 +180,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::hpmv( order(), uplo(), size_column(ap), alpha,
- begin_value(ap), begin_value(x), stride(x), beta,
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::hpmv( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(ap), bindings::begin_value(x),
+ bindings::stride(x), beta, bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -160,14 +160,16 @@
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- detail::hpr( order(), uplo(), size_column(ap), alpha,
- begin_value(x), stride(x), begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ detail::hpr( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(ap) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -168,6 +168,7 @@
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -176,10 +177,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- detail::hpr2( order(), uplo(), size_column(ap), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ detail::hpr2( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y),
+ bindings::begin_value(ap) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -166,6 +166,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const VectorX& x, const real_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -174,11 +175,14 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::sbmv( order(), uplo(), size_column(a),
- bandwidth_upper(a), alpha, begin_value(a), stride_major(a),
- begin_value(x), stride(x), beta, begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::sbmv( order(), uplo(), bindings::size_column(a),
+ bindings::bandwidth_upper(a), alpha, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(x),
+ bindings::stride(x), beta, bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -163,6 +163,7 @@
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixAP& ap,
             const VectorX& x, const real_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -171,10 +172,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- detail::spmv( order(), uplo(), size_column(ap), alpha,
- begin_value(ap), begin_value(x), stride(x), beta,
- begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ detail::spmv( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(ap), bindings::begin_value(x),
+ bindings::stride(x), beta, bindings::begin_value(y),
+ bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -154,14 +154,16 @@
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- detail::spr( order(), uplo(), size_column(ap), alpha,
- begin_value(x), stride(x), begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ detail::spr( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(ap) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -160,6 +160,7 @@
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -168,10 +169,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- detail::spr2( order(), uplo(), size_column(ap), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ detail::spr2( order(), uplo(), bindings::size_column(ap), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y),
+ bindings::begin_value(ap) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -165,6 +165,7 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const VectorX& x, const real_type beta, VectorY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -173,11 +174,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::symv( order(), uplo(), size_column(a), alpha,
- begin_value(a), stride_major(a), begin_value(x), stride(x),
- beta, begin_value(y), stride(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::symv( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x), beta,
+ bindings::begin_value(y), bindings::stride(y) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -156,15 +156,18 @@
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::syr( order(), uplo(), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::syr( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -163,6 +163,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -171,11 +172,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- detail::syr2( order(), uplo(), size_column(a), alpha,
- begin_value(x), stride(x), begin_value(y), stride(y),
- begin_value(a), stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ detail::syr2( order(), uplo(), bindings::size_column(a), alpha,
+ bindings::begin_value(x), bindings::stride(x),
+ bindings::begin_value(y), bindings::stride(y),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -249,6 +249,7 @@
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const std::ptrdiff_t k, const MatrixA& a,
             VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -256,11 +257,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
         detail::tbmv( order(), uplo(), trans(), diag(),
- size_column_op(a, trans()), k, begin_value(a),
- stride_major(a), begin_value(x), stride(x) );
+ bindings::size_column_op(a, trans()), k,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -249,6 +249,7 @@
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const std::ptrdiff_t k, const MatrixA& a,
             VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -256,11 +257,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
         detail::tbsv( order(), uplo(), trans(), diag(),
- size_column_op(a, trans()), k, begin_value(a),
- stride_major(a), begin_value(x), stride(x) );
+ bindings::size_column_op(a, trans()), k,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -243,6 +243,7 @@
     //
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const MatrixAP& ap, VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         typedef typename result_of::trans_tag< MatrixAP, order >::type trans;
@@ -250,10 +251,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
         detail::tpmv( order(), uplo(), trans(), diag(),
- size_column_op(ap, trans()), begin_value(ap), begin_value(x),
- stride(x) );
+ bindings::size_column_op(ap, trans()),
+ bindings::begin_value(ap), bindings::begin_value(x),
+ bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -243,6 +243,7 @@
     //
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const MatrixAP& ap, VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         typedef typename result_of::trans_tag< MatrixAP, order >::type trans;
@@ -250,10 +251,11 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
         detail::tpsv( order(), uplo(), trans(), diag(),
- size_column_op(ap, trans()), begin_value(ap), begin_value(x),
- stride(x) );
+ bindings::size_column_op(ap, trans()),
+ bindings::begin_value(ap), bindings::begin_value(x),
+ bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -244,6 +244,7 @@
     //
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const MatrixA& a, VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -251,11 +252,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
         detail::trmv( order(), uplo(), trans(), diag(),
- size_column_op(a, trans()), begin_value(a), stride_major(a),
- begin_value(x), stride(x) );
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -246,6 +246,7 @@
     //
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const MatrixA& a, VectorX& x ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -253,11 +254,13 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
         detail::trsv( order(), uplo(), trans(), diag(),
- size_column_op(a, trans()), begin_value(a), stride_major(a),
- begin_value(x), stride(x) );
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), bindings::stride(x) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -276,6 +276,7 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const value_type beta, MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type transa;
         typedef typename result_of::trans_tag< MatrixB, order >::type transb;
@@ -285,14 +286,19 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::gemm( order(), transa(), transb(), size_row(c),
- size_column(c), size_column(a), alpha, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b), beta,
- begin_value(c), stride_major(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ detail::gemm( order(), transa(), transb(),
+ bindings::size_row(c), bindings::size_column(c),
+ bindings::size_column(a), alpha, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), beta, bindings::begin_value(c),
+ bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -180,6 +180,7 @@
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
             MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -188,15 +189,19 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::hemm( order(), side, uplo(), size_row(c),
- size_column(c), alpha, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), beta, begin_value(c),
- stride_major(c) );
+ detail::hemm( order(), side, uplo(), bindings::size_row(c),
+ bindings::size_column(c), alpha, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), beta, bindings::begin_value(c),
+ bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -174,6 +174,7 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const real_type beta, MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixB >::type order;
         typedef typename result_of::data_side< MatrixC >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -183,14 +184,18 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::her2k( order(), uplo(), trans(), size_column(c),
- size_column(a), alpha, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), beta, begin_value(c),
- stride_major(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ detail::her2k( order(), uplo(), trans(),
+ bindings::size_column(c), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), beta,
+ bindings::begin_value(c), bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -166,18 +166,22 @@
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const real_type beta, MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::data_side< MatrixC >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::herk( order(), uplo(), trans(), size_column(c),
- size_column(a), alpha, begin_value(a), stride_major(a), beta,
- begin_value(c), stride_major(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ detail::herk( order(), uplo(), trans(),
+ bindings::size_column(c), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a), beta,
+ bindings::begin_value(c), bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -266,6 +266,7 @@
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
             MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
@@ -274,15 +275,19 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::symm( order(), side, uplo(), size_row(c),
- size_column(c), alpha, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), beta, begin_value(c),
- stride_major(c) );
+ detail::symm( order(), side, uplo(), bindings::size_row(c),
+ bindings::size_column(c), alpha, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), beta, bindings::begin_value(c),
+ bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -266,6 +266,7 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const value_type beta, MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixB >::type order;
         typedef typename result_of::data_side< MatrixC >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -275,14 +276,18 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::syr2k( order(), uplo(), trans(), size_column(c),
- size_column(a), alpha, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), beta, begin_value(c),
- stride_major(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ detail::syr2k( order(), uplo(), trans(),
+ bindings::size_column(c), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), beta,
+ bindings::begin_value(c), bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -259,18 +259,22 @@
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const value_type beta, MatrixC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::data_side< MatrixC >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- detail::syrk( order(), uplo(), trans(), size_column(c),
- size_column(a), alpha, begin_value(a), stride_major(a), beta,
- begin_value(c), stride_major(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ detail::syrk( order(), uplo(), trans(),
+ bindings::size_column(c), bindings::size_column(a), alpha,
+ bindings::begin_value(a), bindings::stride_major(a), beta,
+ bindings::begin_value(c), bindings::stride_major(c) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -268,6 +268,7 @@
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixB >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type transa;
@@ -275,13 +276,16 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         detail::trmm( order(), side, uplo(), transa(), diag(),
- size_row(b), size_column(b), alpha, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b) );
+ bindings::size_row(b), bindings::size_column(b), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 };
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -270,6 +270,7 @@
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixB >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type transa;
@@ -277,13 +278,16 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         detail::trsm( order(), side, uplo(), transa(), diag(),
- size_row(b), size_column(b), alpha, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b) );
+ bindings::size_row(b), bindings::size_column(b), alpha,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 };
 

Added: sandbox/numeric_bindings/boost/numeric/bindings/glas/dense_matrix.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/glas/dense_matrix.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,71 @@
+//
+// Copyright (c) 2009 Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DENSE_MATRIX_HPP
+#define BOOST_NUMERIC_BINDINGS_GLAS_DENSE_MATRIX_HPP
+
+#include <boost/numeric/bindings/detail/adaptor.hpp>
+#include <boost/numeric/bindings/detail/if_row_major.hpp>
+#include <boost/numeric/bindings/glas/detail/convert_to.hpp>
+#include <glas/container/dense_matrix.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace detail {
+
+template< typename T, typename O, typename Id, typename Enable >
+struct adaptor< glas::dense_matrix< T, O >, Id, Enable > {
+
+ typedef typename copy_const< Id, T >::type value_type;
+ typedef typename convert_to< tag::data_order, O >::type data_order;
+ typedef mpl::map<
+ mpl::pair< tag::value_type, value_type >,
+ mpl::pair< tag::entity, tag::matrix >,
+ mpl::pair< tag::size_type<1>, std::ptrdiff_t >,
+ mpl::pair< tag::size_type<2>, std::ptrdiff_t >,
+ mpl::pair< tag::data_structure, tag::linear_array >,
+ mpl::pair< tag::data_order, data_order >,
+ mpl::pair< tag::stride_type<1>,
+ typename if_row_major< data_order, std::ptrdiff_t, tag::contiguous >::type >,
+ mpl::pair< tag::stride_type<2>,
+ typename if_row_major< data_order, tag::contiguous, std::ptrdiff_t >::type >
+ > property_map;
+
+ static std::ptrdiff_t size1( const Id& id ) {
+ return id.num_rows();
+ }
+
+ static std::ptrdiff_t size2( const Id& id ) {
+ return id.num_columns();
+ }
+
+ static value_type* begin_value( Id& id ) {
+ return id.storage_ptr();
+ }
+
+ static value_type* end_value( Id& id ) {
+ return id.storage_ptr() + id.num_rows() * id.num_columns();
+ }
+
+ static std::ptrdiff_t stride1( const Id& id ) {
+ return id.num_columns();
+ }
+
+ static std::ptrdiff_t stride2( const Id& id ) {
+ return id.num_rows();
+ }
+
+};
+
+} // namespace detail
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/glas/dense_vector.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/glas/dense_vector.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,51 @@
+//
+// Copyright (c) 2009 Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_HPP
+#define BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_HPP
+
+#include <boost/numeric/bindings/detail/adaptor.hpp>
+#include <glas/container/dense_vector.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace detail {
+
+template< typename T, typename Id, typename Enable >
+struct adaptor< glas::dense_vector< T >, Id, Enable > {
+
+ typedef typename copy_const< Id, T >::type value_type;
+ typedef mpl::map<
+ mpl::pair< tag::value_type, value_type >,
+ mpl::pair< tag::entity, tag::vector >,
+ mpl::pair< tag::size_type<1>, std::ptrdiff_t >,
+ mpl::pair< tag::data_structure, tag::linear_array >,
+ mpl::pair< tag::stride_type<1>, tag::contiguous >
+ > property_map;
+
+ static std::ptrdiff_t size1( const Id& id ) {
+ return id.size();
+ }
+
+ static value_type* begin_value( Id& id ) {
+ return id.storage_ptr();
+ }
+
+ static value_type* end_value( Id& id ) {
+ return id.storage_ptr() + id.size();
+ }
+
+};
+
+} // namespace detail
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Added: sandbox/numeric_bindings/boost/numeric/bindings/glas/detail/convert_to.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/glas/detail/convert_to.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,36 @@
+//
+// Copyright (c) 2009 Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DETAIL_CONVERT_TO_HPP
+#define BOOST_NUMERIC_BINDINGS_GLAS_DETAIL_CONVERT_TO_HPP
+
+#include <boost/numeric/bindings/detail/convert_to.hpp>
+#include <boost/numeric/bindings/tag.hpp>
+#include <glas/concept/orientation.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace detail {
+
+template<>
+struct convert_to< bindings::tag::data_order, glas::row_orientation > {
+ typedef bindings::tag::row_major type;
+};
+
+template<>
+struct convert_to< bindings::tag::data_order, glas::column_orientation > {
+ typedef bindings::tag::column_major type;
+};
+
+} // namespace detail
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -120,17 +120,21 @@
     template< typename MatrixAB, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             detail::workspace1< WORK > work ) {
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
- return detail::langb( norm, size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), begin_value(ab), stride_major(ab),
- begin_value(work.select(real_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
+ return detail::langb( norm, bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -143,6 +147,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( norm, ab, workspace( tmp_work ) );
@@ -158,6 +163,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, ab, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lange.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -117,16 +117,19 @@
     template< typename MatrixA, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             detail::workspace1< WORK > work ) {
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(size_row(a),
- 1) );
- return detail::lange( norm, size_row(a), size_column(a),
- begin_value(a), stride_major(a),
- begin_value(work.select(real_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max<
+ std::ptrdiff_t >(bindings::size_row(a),1) );
+ return detail::lange( norm, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -139,6 +142,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( norm, a, workspace( tmp_work ) );
@@ -154,6 +158,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, a, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -97,16 +97,20 @@
     template< typename MatrixAB, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
- return detail::lanhb( norm, uplo(), size_column(ab),
- bandwidth_lower(ab), begin_value(ab), stride_major(ab),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+1 );
+ return detail::lanhb( norm, uplo(), bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -119,6 +123,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -135,6 +140,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( norm, ab, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -93,15 +93,18 @@
     template< typename MatrixA, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max<
- std::ptrdiff_t >(size_column(a),1) );
- return detail::lanhe( norm, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max<
+ std::ptrdiff_t >(bindings::size_column(a),1) );
+ return detail::lanhe( norm, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -114,6 +117,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -130,6 +134,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( norm, a, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -92,12 +92,14 @@
     template< typename MatrixAP, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::lanhp( norm, uplo(), size_column(ap), begin_value(ap),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::lanhp( norm, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -110,6 +112,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -126,6 +129,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( norm, ap, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -114,14 +114,17 @@
     template< typename MatrixA, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             detail::workspace1< WORK > work ) {
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max<
- std::ptrdiff_t >(size_column(a),1) );
- return detail::lanhs( norm, size_column(a), begin_value(a),
- stride_major(a), begin_value(work.select(real_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max<
+ std::ptrdiff_t >(bindings::size_column(a),1) );
+ return detail::lanhs( norm, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -134,6 +137,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( norm, a, workspace( tmp_work ) );
@@ -149,6 +153,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, a, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -127,16 +127,20 @@
     template< typename MatrixAB, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
- return detail::lansb( norm, uplo(), size_column(ab),
- bandwidth_lower(ab), begin_value(ab), stride_major(ab),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+1 );
+ return detail::lansb( norm, uplo(), bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -149,6 +153,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -165,6 +170,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( norm, ab, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -118,12 +118,14 @@
     template< typename MatrixAP, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::lansp( norm, uplo(), size_column(ap), begin_value(ap),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::lansp( norm, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -136,6 +138,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -152,6 +155,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( norm, ap, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansy.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -119,15 +119,18 @@
     template< typename MatrixA, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max<
- std::ptrdiff_t >(size_column(a),1) );
- return detail::lansy( norm, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max<
+ std::ptrdiff_t >(bindings::size_column(a),1) );
+ return detail::lansy( norm, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -140,6 +143,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -156,6 +160,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( norm, a, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -131,16 +131,18 @@
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const fortran_int_t k, const MatrixAB& ab, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= k+1 );
         BOOST_ASSERT( k >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= k+1 );
- return detail::lantb( norm, uplo, diag(), size_column(ab), k,
- begin_value(ab), stride_major(ab),
- begin_value(work.select(real_type())) );
+ return detail::lantb( norm, uplo, diag(), bindings::size_column(ab),
+ k, bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -154,6 +156,7 @@
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const fortran_int_t k, const MatrixAB& ab,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -171,6 +174,7 @@
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const fortran_int_t k, const MatrixAB& ab,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         return invoke( norm, uplo, k, ab, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -119,12 +119,14 @@
     template< typename MatrixAP, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const MatrixAP& ap, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAP >::type diag;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::lantp( norm, uplo, diag(), size_column(ap),
- begin_value(ap), begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::lantp( norm, uplo, diag(), bindings::size_column(ap),
+ bindings::begin_value(ap),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -137,6 +139,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const MatrixAP& ap, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAP >::type diag;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -153,6 +156,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
             const MatrixAP& ap, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::diag_tag< MatrixAP >::type diag;
         return invoke( norm, uplo, ap, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -128,18 +128,21 @@
     template< typename MatrixA, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(size_row(a),
- 1) );
- return detail::lantr( norm, uplo(), diag(), size_row(a),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max<
+ std::ptrdiff_t >(bindings::size_row(a),1) );
+ return detail::lantr( norm, uplo(), diag(), bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -152,6 +155,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
         bindings::detail::array< real_type > tmp_work( min_size_work(
@@ -169,6 +173,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
         return invoke( norm, a, minimal_workspace() );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -131,20 +131,25 @@
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_column(c),
+ bindings::size_row(c) ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_column(c), size_row(c) ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::larf( side, size_row(c), size_column(c),
- begin_value(v), stride(v), tau, begin_value(c),
- stride_major(c), begin_value(work.select(real_type())) );
+ return detail::larf( side, bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(v),
+ bindings::stride(v), tau, bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -157,8 +162,9 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_column(c), size_row(c) ) );
+ bindings::size_column(c), bindings::size_row(c) ) );
         return invoke( side, v, tau, c, workspace( tmp_work ) );
     }
 
@@ -172,6 +178,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, v, tau, c, minimal_workspace() );
     }
 
@@ -204,20 +211,25 @@
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( side, bindings::size_column(c),
+ bindings::size_row(c) ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( side,
- size_column(c), size_row(c) ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::larf( side, size_row(c), size_column(c),
- begin_value(v), stride(v), tau, begin_value(c),
- stride_major(c), begin_value(work.select(value_type())) );
+ return detail::larf( side, bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(v),
+ bindings::stride(v), tau, bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -230,8 +242,9 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work( side,
- size_column(c), size_row(c) ) );
+ bindings::size_column(c), bindings::size_row(c) ) );
         return invoke( side, v, tau, c, workspace( tmp_work ) );
     }
 
@@ -245,6 +258,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, v, tau, c, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -149,6 +149,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
@@ -157,23 +158,28 @@
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 1 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
+ BOOST_ASSERT( bindings::stride_major(t) >= bindings::size_column(t) );
         BOOST_ASSERT( direct == 'F' || direct == 'B' );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
         BOOST_ASSERT( storev == 'C' || storev == 'R' );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- BOOST_ASSERT( stride_major(t) >= size_column(t) );
- return detail::larfb( side, trans(), direct, storev, size_row(c),
- size_column(c), size_column(t), begin_value(v),
- stride_major(v), begin_value(t), stride_major(t),
- begin_value(c), stride_major(c), begin_value(work),
- stride_major(work) );
+ return detail::larfb( side, trans(), direct, storev,
+ bindings::size_row(c), bindings::size_column(c),
+ bindings::size_column(t), bindings::begin_value(v),
+ bindings::stride_major(v), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(work),
+ bindings::stride_major(work) );
     }
 
     //
@@ -187,6 +193,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( side, direct, storev, v, t, c, workspace( tmp_work ) );
@@ -203,6 +210,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, direct, storev, v, t, c, minimal_workspace() );
     }
 
@@ -235,6 +243,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
@@ -243,23 +252,28 @@
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 1 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
+ BOOST_ASSERT( bindings::stride_major(t) >= bindings::size_column(t) );
         BOOST_ASSERT( direct == 'F' || direct == 'B' );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
         BOOST_ASSERT( storev == 'C' || storev == 'R' );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- BOOST_ASSERT( stride_major(t) >= size_column(t) );
- return detail::larfb( side, trans(), direct, storev, size_row(c),
- size_column(c), size_column(t), begin_value(v),
- stride_major(v), begin_value(t), stride_major(t),
- begin_value(c), stride_major(c), begin_value(work),
- stride_major(work) );
+ return detail::larfb( side, trans(), direct, storev,
+ bindings::size_row(c), bindings::size_column(c),
+ bindings::size_column(t), bindings::begin_value(v),
+ bindings::stride_major(v), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(work),
+ bindings::stride_major(work) );
     }
 
     //
@@ -273,6 +287,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( side, direct, storev, v, t, c, workspace( tmp_work ) );
@@ -289,6 +304,7 @@
     static std::ptrdiff_t invoke( const char side, const char direct,
             const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, direct, storev, v, t, c, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfg.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -122,8 +122,10 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, real_type& alpha,
             VectorX& x, real_type& tau ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- return detail::larfg( n, alpha, begin_value(x), stride(x), tau );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ return detail::larfg( n, alpha, bindings::begin_value(x),
+ bindings::stride(x), tau );
     }
 
 };
@@ -146,8 +148,10 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, value_type& alpha,
             VectorX& x, value_type& tau ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- return detail::larfg( n, alpha, begin_value(x), stride(x), tau );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ return detail::larfg( n, alpha, bindings::begin_value(x),
+ bindings::stride(x), tau );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larft.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -120,6 +120,7 @@
     static std::ptrdiff_t invoke( const char direct, const char storev,
             const fortran_int_t n, const fortran_int_t k, MatrixV& v,
             const VectorTAU& tau, MatrixT& t ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
@@ -128,19 +129,21 @@
                 typename value< MatrixV >::type >::type,
                 typename remove_const< typename value<
                 MatrixT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 1 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::stride_major(t) >= k );
         BOOST_ASSERT( direct == 'F' || direct == 'B' );
         BOOST_ASSERT( k >= 1 );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
         BOOST_ASSERT( storev == 'C' || storev == 'R' );
- BOOST_ASSERT( stride_major(t) >= k );
- return detail::larft( direct, storev, n, k, begin_value(v),
- stride_major(v), begin_value(tau), begin_value(t),
- stride_major(t) );
+ return detail::larft( direct, storev, n, k, bindings::begin_value(v),
+ bindings::stride_major(v), bindings::begin_value(tau),
+ bindings::begin_value(t), bindings::stride_major(t) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larfx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,19 +129,22 @@
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= (ERROR) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= (ERROR) );
- return detail::larfx( side, size_row(c), size_column(c),
- begin_value(v), tau, begin_value(c), stride_major(c),
- begin_value(work.select(real_type())) );
+ return detail::larfx( side, bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(v), tau,
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -154,6 +157,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( side, v, tau, c, workspace( tmp_work ) );
@@ -169,6 +173,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const real_type tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, v, tau, c, minimal_workspace() );
     }
 
@@ -200,20 +205,23 @@
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::larfx( side, size_row(c), size_column(c),
- begin_value(v), tau, begin_value(c), stride_major(c),
- begin_value(work.select(value_type())) );
+ return detail::larfx( side, bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(v), tau,
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -226,6 +234,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( side, v, tau, c, workspace( tmp_work ) );
@@ -241,6 +250,7 @@
     template< typename VectorV, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const VectorV& v,
             const value_type tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, v, tau, c, minimal_workspace() );
     }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/largv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -124,6 +124,7 @@
     template< typename VectorX, typename VectorY, typename VectorC >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             VectorY& y, VectorC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorX >::type >::type,
                 typename remove_const< typename value<
@@ -132,14 +133,16 @@
                 typename value< VectorX >::type >::type,
                 typename remove_const< typename value<
                 VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( size(c) >= 1+(n-1)*stride(c) );
- BOOST_ASSERT( size(x) >= 1+(n-1)*stride(x) );
- BOOST_ASSERT( size(y) >= 1+(n-1)*stride(y) );
- return detail::largv( n, begin_value(x), stride(x), begin_value(y),
- stride(y), begin_value(c), stride(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) );
+ BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) );
+ BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) );
+ return detail::largv( n, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), bindings::begin_value(c),
+ bindings::stride(c) );
     }
 
 };
@@ -162,18 +165,21 @@
     template< typename VectorX, typename VectorY, typename VectorC >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             VectorY& y, VectorC& c ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorX >::type >::type,
                 typename remove_const< typename value<
                 VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( size(c) >= 1+(n-1)*stride(c) );
- BOOST_ASSERT( size(x) >= 1+(n-1)*stride(x) );
- BOOST_ASSERT( size(y) >= 1+(n-1)*stride(y) );
- return detail::largv( n, begin_value(x), stride(x), begin_value(y),
- stride(y), begin_value(c), stride(c) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) );
+ BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) );
+ BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) );
+ return detail::largv( n, bindings::begin_value(x),
+ bindings::stride(x), bindings::begin_value(y),
+ bindings::stride(y), bindings::begin_value(c),
+ bindings::stride(c) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larnv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -111,11 +111,13 @@
     template< typename VectorISEED, typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t idist,
             VectorISEED& iseed, const fortran_int_t n, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorISEED >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size(iseed) >= 4 );
- BOOST_ASSERT( size(x) >= n );
- return detail::larnv( idist, begin_value(iseed), n, begin_value(x) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISEED >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size(iseed) >= 4 );
+ BOOST_ASSERT( bindings::size(x) >= n );
+ return detail::larnv( idist, bindings::begin_value(iseed), n,
+ bindings::begin_value(x) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larrb.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -106,6 +106,7 @@
             VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
             const real_type spdiam, const fortran_int_t twist,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -122,22 +123,24 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 VectorWERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWGAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWERR >::value) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(lld) >= n-1 );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(werr) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWGAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWERR >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(lld) >= n-1 );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(werr) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
                 min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- return detail::larrb( n, begin_value(d), begin_value(lld), ifirst,
- ilast, rtol1, rtol2, offset, begin_value(w),
- begin_value(wgap), begin_value(werr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())), pivmin, spdiam,
- twist );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ return detail::larrb( n, bindings::begin_value(d),
+ bindings::begin_value(lld), ifirst, ilast, rtol1, rtol2,
+ offset, bindings::begin_value(w), bindings::begin_value(wgap),
+ bindings::begin_value(werr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ pivmin, spdiam, twist );
     }
 
     //
@@ -156,6 +159,7 @@
             VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
             const real_type spdiam, const fortran_int_t twist,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 min_size_iwork( n ) );
@@ -180,6 +184,7 @@
             VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin,
             const real_type spdiam, const fortran_int_t twist,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w,
                 wgap, werr, pivmin, spdiam, twist, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larre.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -114,6 +114,7 @@
             VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
             VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -146,36 +147,39 @@
                 typename value< VectorISPLIT >::type >::type,
                 typename remove_const< typename value<
                 VectorINDEXW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE2 >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISPLIT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWGAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIBLOCK >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorINDEXW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorGERS >::value) );
- BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(e2) >= n );
- BOOST_ASSERT( size(gers) >= 2*n );
- BOOST_ASSERT( size(indexw) >= n );
- BOOST_ASSERT( size(isplit) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(werr) >= n );
- BOOST_ASSERT( size(wgap) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE2 >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISPLIT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWGAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIBLOCK >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorINDEXW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorGERS >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(e2) >= n );
+ BOOST_ASSERT( bindings::size(gers) >= 2*n );
+ BOOST_ASSERT( bindings::size(indexw) >= n );
+ BOOST_ASSERT( bindings::size(isplit) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(werr) >= n );
+ BOOST_ASSERT( bindings::size(wgap) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
                 min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- return detail::larre( range, n, vl, vu, il, iu, begin_value(d),
- begin_value(e), begin_value(e2), rtol1, rtol2, spltol, nsplit,
- begin_value(isplit), m, begin_value(w), begin_value(werr),
- begin_value(wgap), begin_value(iblock), begin_value(indexw),
- begin_value(gers), pivmin,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ return detail::larre( range, n, vl, vu, il, iu,
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(e2), rtol1, rtol2, spltol, nsplit,
+ bindings::begin_value(isplit), m, bindings::begin_value(w),
+ bindings::begin_value(werr), bindings::begin_value(wgap),
+ bindings::begin_value(iblock), bindings::begin_value(indexw),
+ bindings::begin_value(gers), pivmin,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -198,6 +202,7 @@
             VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
             VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 min_size_iwork( n ) );
@@ -226,6 +231,7 @@
             VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock,
             VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2,
                 spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw,
                 gers, pivmin, minimal_workspace() );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
             const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u,
             MatrixVT& vt, VectorQ& q, VectorIQ& iq, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -116,26 +117,30 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 VectorQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIQ >::value) );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( compq, n ));
+ BOOST_ASSERT( bindings::size_minor(u) == 1 ||
+ bindings::stride_minor(u) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vt) == 1 ||
+ bindings::stride_minor(vt) == 1 );
         BOOST_ASSERT( compq == 'N' || compq == 'P' || compq == 'I' );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( compq,
- n ));
- BOOST_ASSERT( size_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(vt) == 1 || stride_minor(vt) == 1 );
- return detail::bdsdc( uplo, compq, n, begin_value(d), begin_value(e),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), begin_value(q), begin_value(iq),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::bdsdc( uplo, compq, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(u),
+ bindings::stride_major(u), bindings::begin_value(vt),
+ bindings::stride_major(vt), bindings::begin_value(q),
+ bindings::begin_value(iq),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -150,6 +155,7 @@
     static std::ptrdiff_t invoke( const char uplo, const char compq,
             const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u,
             MatrixVT& vt, VectorQ& q, VectorIQ& iq, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( compq,
                 n ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -170,6 +176,7 @@
     static std::ptrdiff_t invoke( const char uplo, const char compq,
             const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u,
             MatrixVT& vt, VectorQ& q, VectorIQ& iq, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, compq, n, d, e, u, vt, q, iq,
                 minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,6 +143,7 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -159,27 +160,33 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n, bindings::size_column(vt),
+ bindings::size_row(u), bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_column(vt) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(u) == 1 ||
+ bindings::stride_minor(u) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vt) == 1 ||
+ bindings::stride_minor(vt) == 1 );
+ BOOST_ASSERT( bindings::size_row(u) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(u) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(u)) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- size_column(vt), size_row(u), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_column(vt) >= 0 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(vt) == 1 || stride_minor(vt) == 1 );
- BOOST_ASSERT( size_row(u) >= 0 );
- BOOST_ASSERT( stride_major(u) >= std::max< std::ptrdiff_t >(1,
- size_row(u)) );
- return detail::bdsqr( uplo, n, size_column(vt), size_row(u),
- size_column(c), begin_value(d), begin_value(e),
- begin_value(vt), stride_major(vt), begin_value(u),
- stride_major(u), begin_value(c), stride_major(c),
- begin_value(work.select(real_type())) );
+ return detail::bdsqr( uplo, n, bindings::size_column(vt),
+ bindings::size_row(u), bindings::size_column(c),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -194,8 +201,10 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n,
- size_column(vt), size_row(u), size_column(c) ) );
+ bindings::size_column(vt), bindings::size_row(u),
+ bindings::size_column(c) ) );
         return invoke( uplo, n, d, e, vt, u, c, workspace( tmp_work ) );
     }
 
@@ -211,6 +220,7 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, n, d, e, vt, u, c, minimal_workspace() );
     }
 
@@ -248,6 +258,7 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             detail::workspace1< RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -260,27 +271,33 @@
                 typename value< MatrixVT >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( n, bindings::size_column(vt),
+ bindings::size_row(u), bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_column(vt) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(u) == 1 ||
+ bindings::stride_minor(u) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vt) == 1 ||
+ bindings::stride_minor(vt) == 1 );
+ BOOST_ASSERT( bindings::size_row(u) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(u) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(u)) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n,
- size_column(vt), size_row(u), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_column(vt) >= 0 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(vt) == 1 || stride_minor(vt) == 1 );
- BOOST_ASSERT( size_row(u) >= 0 );
- BOOST_ASSERT( stride_major(u) >= std::max< std::ptrdiff_t >(1,
- size_row(u)) );
- return detail::bdsqr( uplo, n, size_column(vt), size_row(u),
- size_column(c), begin_value(d), begin_value(e),
- begin_value(vt), stride_major(vt), begin_value(u),
- stride_major(u), begin_value(c), stride_major(c),
- begin_value(work.select(real_type())) );
+ return detail::bdsqr( uplo, n, bindings::size_column(vt),
+ bindings::size_row(u), bindings::size_column(c),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -295,8 +312,10 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n,
- size_column(vt), size_row(u), size_column(c) ) );
+ bindings::size_column(vt), bindings::size_row(u),
+ bindings::size_column(c) ) );
         return invoke( uplo, n, d, e, vt, u, c, workspace( tmp_rwork ) );
     }
 
@@ -312,6 +331,7 @@
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, n, d, e, vt, u, c, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -150,6 +150,7 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -170,37 +171,48 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixPT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(d) >= std::min< std::ptrdiff_t >(size_row(ab),
- size_column(ab)) );
- BOOST_ASSERT( size(e) >= std::min< std::ptrdiff_t >(size_row(ab),
- size_column(ab))-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(ab), size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(pt) == 1 || stride_minor(pt) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_row(ab) >= 0 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixPT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(d) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(ab),
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::size(e) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(ab),
+ bindings::size_column(ab))-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(ab),
+ bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(pt) == 1 ||
+ bindings::stride_minor(pt) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_row(ab) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
         BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' ||
                 vect == 'B' );
- return detail::gbbrd( vect, size_row(ab), size_column(ab),
- size_column(c), bandwidth_lower(ab), bandwidth_upper(ab),
- begin_value(ab), stride_major(ab), begin_value(d),
- begin_value(e), begin_value(q), stride_major(q),
- begin_value(pt), stride_major(pt), begin_value(c),
- stride_major(c), begin_value(work.select(real_type())) );
+ return detail::gbbrd( vect, bindings::size_row(ab),
+ bindings::size_column(ab), bindings::size_column(c),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(pt), bindings::stride_major(pt),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -215,8 +227,9 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(ab), size_column(ab) ) );
+ bindings::size_row(ab), bindings::size_column(ab) ) );
         return invoke( vect, ab, d, e, q, pt, c, workspace( tmp_work ) );
     }
 
@@ -232,6 +245,7 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( vect, ab, d, e, q, pt, c, minimal_workspace() );
     }
 
@@ -266,6 +280,7 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -282,40 +297,52 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixPT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(d) >= std::min< std::ptrdiff_t >(size_row(ab),
- size_column(ab)) );
- BOOST_ASSERT( size(e) >= std::min< std::ptrdiff_t >(size_row(ab),
- size_column(ab))-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_row(ab), size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(ab), size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(pt) == 1 || stride_minor(pt) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_row(ab) >= 0 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixPT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(d) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(ab),
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::size(e) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(ab),
+ bindings::size_column(ab))-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_row(ab),
+ bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(ab),
+ bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(pt) == 1 ||
+ bindings::stride_minor(pt) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_row(ab) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
         BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' ||
                 vect == 'B' );
- return detail::gbbrd( vect, size_row(ab), size_column(ab),
- size_column(c), bandwidth_lower(ab), bandwidth_upper(ab),
- begin_value(ab), stride_major(ab), begin_value(d),
- begin_value(e), begin_value(q), stride_major(q),
- begin_value(pt), stride_major(pt), begin_value(c),
- stride_major(c), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gbbrd( vect, bindings::size_row(ab),
+ bindings::size_column(ab), bindings::size_column(c),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(pt), bindings::stride_major(pt),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -330,10 +357,11 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(ab), size_column(ab) ) );
+ bindings::size_row(ab), bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_row(ab), size_column(ab) ) );
+ bindings::size_row(ab), bindings::size_column(ab) ) );
         return invoke( vect, ab, d, e, q, pt, c, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -350,6 +378,7 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( vect, ab, d, e, q, pt, c, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,22 +140,25 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             detail::workspace2< WORK, IWORK > work ) {
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= 2 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(ipiv) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= 2 );
- return detail::gbcon( norm, size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), begin_value(ab), stride_major(ab),
- begin_value(ipiv), anorm, rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gbcon( norm, bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(ipiv), anorm, rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -169,10 +172,11 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
         return invoke( norm, ab, ipiv, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -188,6 +192,7 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() );
     }
 
@@ -228,22 +233,25 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             detail::workspace2< WORK, RWORK > work ) {
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= 2 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(ipiv) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= 2 );
- return detail::gbcon( norm, size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), begin_value(ab), stride_major(ab),
- begin_value(ipiv), anorm, rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gbcon( norm, bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(ipiv), anorm, rcond,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -257,10 +265,11 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( norm, ab, ipiv, anorm, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -276,6 +285,7 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
             const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,6 +133,7 @@
     template< typename MatrixAB, typename VectorR, typename VectorC >
     static std::ptrdiff_t invoke( const MatrixAB& ab, VectorR& r, VectorC& c,
             real_type& rowcnd, real_type& colcnd, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -141,19 +142,22 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_row(ab) >= 0 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
- return detail::gbequ( size_row(ab), size_column(ab),
- bandwidth_lower(ab), bandwidth_upper(ab), begin_value(ab),
- stride_major(ab), begin_value(r), begin_value(c), rowcnd,
- colcnd, amax );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_row(ab) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
+ return detail::gbequ( bindings::size_row(ab),
+ bindings::size_column(ab), bindings::bandwidth_lower(ab),
+ bindings::bandwidth_upper(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(r),
+ bindings::begin_value(c), rowcnd, colcnd, amax );
     }
 
 };
@@ -176,23 +180,27 @@
     template< typename MatrixAB, typename VectorR, typename VectorC >
     static std::ptrdiff_t invoke( const MatrixAB& ab, VectorR& r, VectorC& c,
             real_type& rowcnd, real_type& colcnd, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorR >::type >::type,
                 typename remove_const< typename value<
                 VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_row(ab) >= 0 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
- return detail::gbequ( size_row(ab), size_column(ab),
- bandwidth_lower(ab), bandwidth_upper(ab), begin_value(ab),
- stride_major(ab), begin_value(r), begin_value(c), rowcnd,
- colcnd, amax );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_row(ab) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
+ return detail::gbequ( bindings::size_row(ab),
+ bindings::size_column(ab), bindings::bandwidth_lower(ab),
+ bindings::bandwidth_upper(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(r),
+ bindings::begin_value(c), rowcnd, colcnd, amax );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -162,6 +162,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -182,37 +183,45 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
- BOOST_ASSERT( stride_major(afb) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::gbrfs( trans(), size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), size_column(b), begin_value(ab),
- stride_major(ab), begin_value(afb), stride_major(afb),
- begin_value(ipiv), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(afb) == 1 ||
+ bindings::stride_minor(afb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
+ BOOST_ASSERT( bindings::stride_major(afb) >= 2 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::gbrfs( trans(), bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::size_column(b), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(afb),
+ bindings::stride_major(afb), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -228,10 +237,11 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
         return invoke( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -249,6 +259,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
 
@@ -291,6 +302,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
                 typename remove_const< typename value<
@@ -307,37 +319,45 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
- bandwidth_upper(ab)+1 );
- BOOST_ASSERT( stride_major(afb) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::gbrfs( trans(), size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), size_column(b), begin_value(ab),
- stride_major(ab), begin_value(afb), stride_major(afb),
- begin_value(ipiv), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(afb) == 1 ||
+ bindings::stride_minor(afb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+
+ 1 );
+ BOOST_ASSERT( bindings::stride_major(afb) >= 2 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::gbrfs( trans(), bindings::size_column(ab),
+ bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab),
+ bindings::size_column(b), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(afb),
+ bindings::stride_major(afb), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -353,10 +373,11 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -374,6 +395,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -117,19 +117,23 @@
     //
     template< typename MatrixAB, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAB& ab, VectorIPIV& ipiv ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(ipiv) >= std::min< std::ptrdiff_t >(size_row(ab),
- size_column(ab)) );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_row(ab) >= 0 );
- BOOST_ASSERT( stride_major(ab) >= 2 );
- return detail::gbtrf( size_row(ab), size_column(ab),
- bandwidth_lower(ab), bandwidth_upper(ab), begin_value(ab),
- stride_major(ab), begin_value(ipiv) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(ipiv) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(ab),
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_row(ab) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= 2 );
+ return detail::gbtrf( bindings::size_row(ab),
+ bindings::size_column(ab), bindings::bandwidth_lower(ab),
+ bindings::bandwidth_upper(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(ipiv) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -131,26 +131,32 @@
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixAB& ab, const VectorIPIV& ipiv,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixAB, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bandwidth_lower_op(ab, trans()) >= 0 );
- BOOST_ASSERT( bandwidth_upper_op(ab, trans()) >= 0 );
- BOOST_ASSERT( size(ipiv) >= size_column_op(ab, trans()) );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_column_op(ab, trans()) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(ab) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column_op(ab, trans())) );
- return detail::gbtrs( trans(), size_column_op(ab, trans()),
- bandwidth_lower_op(ab, trans()), bandwidth_upper_op(ab,
- trans()), size_column(b), begin_value(ab), stride_major(ab),
- begin_value(ipiv), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper_op(ab, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(ab,
+ trans()) );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= 2 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(ab, trans())) );
+ return detail::gbtrs( trans(), bindings::size_column_op(ab, trans()),
+ bindings::bandwidth_lower_op(ab, trans()),
+ bindings::bandwidth_upper_op(ab, trans()),
+ bindings::size_column(b), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,22 +129,24 @@
     static std::ptrdiff_t invoke( const char job, const char side,
             const fortran_int_t ilo, const fortran_int_t ihi,
             const VectorSCALE& scale, MatrixV& v ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorSCALE >::type >::type,
                 typename remove_const< typename value<
                 MatrixV >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_ASSERT( bindings::size(scale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size_column(v) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(v) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(v)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
         BOOST_ASSERT( side == 'R' || side == 'L' );
- BOOST_ASSERT( size(scale) >= size_row(v) );
- BOOST_ASSERT( size_column(v) >= 0 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(v) >= 0 );
- BOOST_ASSERT( stride_major(v) >= std::max< std::ptrdiff_t >(1,
- size_row(v)) );
- return detail::gebak( job, side, size_row(v), ilo, ihi,
- begin_value(scale), size_column(v), begin_value(v),
- stride_major(v) );
+ return detail::gebak( job, side, bindings::size_row(v), ilo, ihi,
+ bindings::begin_value(scale), bindings::size_column(v),
+ bindings::begin_value(v), bindings::stride_major(v) );
     }
 
 };
@@ -168,18 +170,20 @@
     static std::ptrdiff_t invoke( const char job, const char side,
             const fortran_int_t ilo, const fortran_int_t ihi,
             const VectorSCALE& scale, MatrixV& v ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_ASSERT( bindings::size(scale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size_column(v) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(v) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(v)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
         BOOST_ASSERT( side == 'R' || side == 'L' );
- BOOST_ASSERT( size(scale) >= size_row(v) );
- BOOST_ASSERT( size_column(v) >= 0 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(v) >= 0 );
- BOOST_ASSERT( stride_major(v) >= std::max< std::ptrdiff_t >(1,
- size_row(v)) );
- return detail::gebak( job, side, size_row(v), ilo, ihi,
- begin_value(scale), size_column(v), begin_value(v),
- stride_major(v) );
+ return detail::gebak( job, side, bindings::size_row(v), ilo, ihi,
+ bindings::begin_value(scale), bindings::size_column(v),
+ bindings::begin_value(v), bindings::stride_major(v) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -125,19 +125,22 @@
     static std::ptrdiff_t invoke( const char job, MatrixA& a,
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorSCALE& scale ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorSCALE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gebal( job, size_column(a), begin_value(a),
- stride_major(a), ilo, ihi, begin_value(scale) );
+ return detail::gebal( job, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), ilo, ihi,
+ bindings::begin_value(scale) );
     }
 
 };
@@ -161,15 +164,18 @@
     static std::ptrdiff_t invoke( const char job, MatrixA& a,
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorSCALE& scale ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSCALE >::value) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gebal( job, size_column(a), begin_value(a),
- stride_major(a), ilo, ihi, begin_value(scale) );
+ return detail::gebal( job, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), ilo, ihi,
+ bindings::begin_value(scale) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -131,6 +131,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -147,29 +148,35 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUP >::value) );
- BOOST_ASSERT( size(d) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taup) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(tauq) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a), size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gebrd( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tauq), begin_value(taup),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
+ BOOST_ASSERT( bindings::size(d) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taup) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(tauq) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gebrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tauq), bindings::begin_value(taup),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -183,8 +190,9 @@
             typename VectorTAUQ, typename VectorTAUP >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a), size_column(a) ) );
+ bindings::size_row(a), bindings::size_column(a) ) );
         return invoke( a, d, e, tauq, taup, workspace( tmp_work ) );
     }
 
@@ -199,10 +207,13 @@
             typename VectorTAUQ, typename VectorTAUP >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::gebrd( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tauq), begin_value(taup), &opt_size_work, -1 );
+ detail::gebrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tauq), bindings::begin_value(taup),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, d, e, tauq, taup, workspace( tmp_work ) );
@@ -239,6 +250,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -251,29 +263,35 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUP >::value) );
- BOOST_ASSERT( size(d) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taup) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(tauq) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gebrd( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tauq), begin_value(taup),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
+ BOOST_ASSERT( bindings::size(d) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taup) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(tauq) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gebrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tauq), bindings::begin_value(taup),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -287,8 +305,9 @@
             typename VectorTAUQ, typename VectorTAUP >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a) ) );
+ bindings::size_row(a), bindings::size_column(a) ) );
         return invoke( a, d, e, tauq, taup, workspace( tmp_work ) );
     }
 
@@ -303,10 +322,13 @@
             typename VectorTAUQ, typename VectorTAUP >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::gebrd( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tauq), begin_value(taup), &opt_size_work, -1 );
+ detail::gebrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tauq), bindings::begin_value(taup),
+ &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, d, e, tauq, taup, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,19 +129,21 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gecon( norm, size_column(a), begin_value(a),
- stride_major(a), anorm, rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gecon( norm, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), anorm,
+ rcond, bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -154,10 +156,11 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
         return invoke( norm, a, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -172,6 +175,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, a, anorm, rcond, minimal_workspace() );
     }
 
@@ -211,19 +215,21 @@
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gecon( norm, size_column(a), begin_value(a),
- stride_major(a), anorm, rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gecon( norm, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), anorm,
+ rcond, bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -236,10 +242,11 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( norm, a, anorm, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -254,6 +261,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( norm, a, anorm, rcond, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -124,6 +124,7 @@
     template< typename MatrixA, typename VectorR, typename VectorC >
     static std::ptrdiff_t invoke( const MatrixA& a, VectorR& r, VectorC& c,
             real_type& rowcnd, real_type& colcnd, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -132,15 +133,17 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geequ( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(r), begin_value(c), rowcnd,
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geequ( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(r), bindings::begin_value(c), rowcnd,
                 colcnd, amax );
     }
 
@@ -164,19 +167,22 @@
     template< typename MatrixA, typename VectorR, typename VectorC >
     static std::ptrdiff_t invoke( const MatrixA& a, VectorR& r, VectorC& c,
             real_type& rowcnd, real_type& colcnd, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorR >::type >::type,
                 typename remove_const< typename value<
                 VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geequ( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(r), begin_value(c), rowcnd,
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geequ( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(r), bindings::begin_value(c), rowcnd,
                 colcnd, amax );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -130,23 +130,26 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= size_column(a)-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gehrd( size_column(a), ilo, ihi, begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::gehrd( bindings::size_column(a), ilo, ihi,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -160,6 +163,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( ilo, ihi, a, tau, workspace( tmp_work ) );
@@ -176,9 +180,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::gehrd( size_column(a), ilo, ihi, begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gehrd( bindings::size_column(a), ilo, ihi,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( ilo, ihi, a, tau, workspace( tmp_work ) );
@@ -212,23 +218,26 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= size_column(a)-1 );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gehrd( size_column(a), ilo, ihi, begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::gehrd( bindings::size_column(a), ilo, ihi,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -242,6 +251,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( ilo, ihi, a, tau, workspace( tmp_work ) );
@@ -258,9 +268,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t ilo,
             const fortran_int_t ihi, MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::gehrd( size_column(a), ilo, ihi, begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gehrd( bindings::size_column(a), ilo, ihi,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( ilo, ihi, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,25 +129,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gelqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gelqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -160,8 +164,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a) ) );
+ bindings::size_row(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -175,9 +180,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::gelqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gelqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -210,25 +217,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gelqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gelqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -241,8 +252,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a) ) );
+ bindings::size_row(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -256,9 +268,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::gelqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gelqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,25 +129,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqlf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqlf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -160,8 +164,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -175,9 +180,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::geqlf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::geqlf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -210,25 +217,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqlf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqlf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -241,8 +252,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -256,9 +268,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::geqlf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::geqlf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -130,26 +130,30 @@
             typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorJPVT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqp3( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(jpvt), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqp3( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(jpvt), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -162,8 +166,9 @@
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, jpvt, tau, workspace( tmp_work ) );
     }
 
@@ -177,9 +182,11 @@
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::geqp3( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(jpvt), begin_value(tau),
+ detail::geqp3( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(jpvt), bindings::begin_value(tau),
                 &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
@@ -214,29 +221,33 @@
             typename WORK, typename RWORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorJPVT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqp3( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(jpvt), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqp3( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(jpvt), bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -249,10 +260,11 @@
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, jpvt, tau, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -266,12 +278,14 @@
     template< typename MatrixA, typename VectorJPVT, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
- detail::geqp3( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(jpvt), begin_value(tau),
- &opt_size_work, -1, begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::geqp3( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(jpvt), bindings::begin_value(tau),
+ &opt_size_work, -1, bindings::begin_value(tmp_rwork) );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, jpvt, tau, workspace( tmp_work, tmp_rwork ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,25 +129,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqrf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -160,8 +164,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -175,9 +180,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::geqrf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::geqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -210,25 +217,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::geqrf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::geqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -241,8 +252,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -256,9 +268,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::geqrf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::geqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -153,6 +153,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -174,36 +175,43 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column_op(a, trans()) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column_op(a, trans()) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column_op(a, trans()) ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(af) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- return detail::gerfs( trans(), size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(af), stride_major(af), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a,
+ trans()) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column_op(a, trans()) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column_op(a, trans()) ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(af) == 1 ||
+ bindings::stride_minor(af) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(af) >= std::max<
+ std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ return detail::gerfs( trans(), bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(af),
+ bindings::stride_major(af), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -219,11 +227,12 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column_op(a, trans()) ) );
+ bindings::size_column_op(a, trans()) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column_op(a, trans()) ) );
+ min_size_iwork( bindings::size_column_op(a, trans()) ) );
         return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -241,6 +250,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
@@ -284,6 +294,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -301,36 +312,43 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column_op(a, trans()) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column_op(a, trans()) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column_op(a, trans()) ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(af) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- return detail::gerfs( trans(), size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(af), stride_major(af), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a,
+ trans()) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column_op(a, trans()) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column_op(a, trans()) ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(af) == 1 ||
+ bindings::stride_minor(af) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(af) >= std::max<
+ std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ return detail::gerfs( trans(), bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(af),
+ bindings::stride_major(af), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -346,11 +364,12 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column_op(a, trans()) ) );
+ bindings::size_column_op(a, trans()) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column_op(a, trans()) ) );
+ bindings::size_column_op(a, trans()) ) );
         return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -368,6 +387,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,25 +129,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gerqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gerqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -160,6 +164,7 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -175,9 +180,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::gerqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gerqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -210,25 +217,29 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gerqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gerqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -241,6 +252,7 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, tau, workspace( tmp_work ) );
@@ -256,9 +268,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::gerqf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::gerqf( bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -181,17 +181,21 @@
     //
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( size(ipiv) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::getrf( order(), size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(ipiv) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::getrf( order(), bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(ipiv) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -194,18 +194,21 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::getri( order(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::getri( order(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -218,8 +221,9 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, ipiv, workspace( tmp_work ) );
     }
 
@@ -233,9 +237,11 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::getri( order(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv), &opt_size_work, -1 );
+ detail::getri( order(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, ipiv, workspace( tmp_work ) );
@@ -268,18 +274,21 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::getri( order(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::getri( order(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -292,8 +301,9 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, ipiv, workspace( tmp_work ) );
     }
 
@@ -307,9 +317,11 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::getri( order(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv), &opt_size_work, -1 );
+ detail::getri( order(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, ipiv, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -197,24 +197,29 @@
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column_op(a, trans()) );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column_op(a, trans())) );
- return detail::getrs( order(), trans(), size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(ipiv), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a,
+ trans()) );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(a, trans())) );
+ return detail::getrs( order(), trans(), bindings::size_column_op(a,
+ trans()), bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -136,6 +136,7 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             const VectorLSCALE& lscale, const VectorRSCALE& rscale,
             MatrixV& v ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorLSCALE >::type >::type,
                 typename remove_const< typename value<
@@ -144,19 +145,21 @@
                 typename value< VectorLSCALE >::type >::type,
                 typename remove_const< typename value<
                 MatrixV >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_ASSERT( bindings::size(lscale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size(rscale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size_column(v) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(v) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(v)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
         BOOST_ASSERT( side == 'R' || side == 'L' );
- BOOST_ASSERT( size(lscale) >= size_row(v) );
- BOOST_ASSERT( size(rscale) >= size_row(v) );
- BOOST_ASSERT( size_column(v) >= 0 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(v) >= 0 );
- BOOST_ASSERT( stride_major(v) >= std::max< std::ptrdiff_t >(1,
- size_row(v)) );
- return detail::ggbak( job, side, size_row(v), ilo, ihi,
- begin_value(lscale), begin_value(rscale), size_column(v),
- begin_value(v), stride_major(v) );
+ return detail::ggbak( job, side, bindings::size_row(v), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ bindings::size_column(v), bindings::begin_value(v),
+ bindings::stride_major(v) );
     }
 
 };
@@ -181,23 +184,26 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             const VectorLSCALE& lscale, const VectorRSCALE& rscale,
             MatrixV& v ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorLSCALE >::type >::type,
                 typename remove_const< typename value<
                 VectorRSCALE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_ASSERT( bindings::size(lscale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size(rscale) >= bindings::size_row(v) );
+ BOOST_ASSERT( bindings::size_column(v) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(v) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(v)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
         BOOST_ASSERT( side == 'R' || side == 'L' );
- BOOST_ASSERT( size(lscale) >= size_row(v) );
- BOOST_ASSERT( size(rscale) >= size_row(v) );
- BOOST_ASSERT( size_column(v) >= 0 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(v) >= 0 );
- BOOST_ASSERT( stride_major(v) >= std::max< std::ptrdiff_t >(1,
- size_row(v)) );
- return detail::ggbak( job, side, size_row(v), ilo, ihi,
- begin_value(lscale), begin_value(rscale), size_column(v),
- begin_value(v), stride_major(v) );
+ return detail::ggbak( job, side, bindings::size_row(v), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ bindings::size_column(v), bindings::begin_value(v),
+ bindings::stride_major(v) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -137,6 +137,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -149,24 +150,27 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorRSCALE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::ggbal( job, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b), ilo, ihi,
- begin_value(lscale), begin_value(rscale),
- begin_value(work.select(real_type())) );
+ return detail::ggbal( job, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -182,6 +186,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( job, a, b, ilo, ihi, lscale, rscale,
@@ -201,6 +206,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 minimal_workspace() );
     }
@@ -235,6 +241,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorLSCALE >::type >::type,
                 typename remove_const< typename value<
@@ -243,24 +250,27 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::ggbal( job, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b), ilo, ihi,
- begin_value(lscale), begin_value(rscale),
- begin_value(work.select(real_type())) );
+ return detail::ggbal( job, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -276,6 +286,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( job, a, b, ilo, ihi, lscale, rscale,
@@ -295,6 +306,7 @@
             fortran_int_t& ilo, fortran_int_t& ihi,
             VectorLSCALE& lscale, VectorRSCALE& rscale,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,6 +133,7 @@
     static std::ptrdiff_t invoke( const char compq, const char compz,
             const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q,
             MatrixZ& z ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -145,25 +146,31 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
         BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gghrd( compq, compz, size_column(a), ilo,
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(q),
- stride_major(q), begin_value(z), stride_major(z) );
+ return detail::gghrd( compq, compz, bindings::size_column(a), ilo,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(z),
+ bindings::stride_major(z) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
             typename VectorTAUB, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -152,30 +153,36 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(b)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::ggqrf( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) );
+ BOOST_ASSERT( bindings::size(taua) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taub) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(b)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::ggqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -189,6 +196,7 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -205,11 +213,13 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::ggqrf( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- &opt_size_work, -1 );
+ detail::ggqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -243,6 +253,7 @@
             typename VectorTAUB, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -255,30 +266,36 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(b)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::ggqrf( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) );
+ BOOST_ASSERT( bindings::size(taua) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taub) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(b)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::ggqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -292,6 +309,7 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -308,11 +326,13 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::ggqrf( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- &opt_size_work, -1 );
+ detail::ggqrf( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
             typename VectorTAUB, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -152,30 +153,36 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( size_row(b) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggrqf( size_row(a), size_row(b), size_column(a),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) );
+ BOOST_ASSERT( bindings::size(taua) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taub) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(b),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::size_row(b) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(b)) );
+ return detail::ggrqf( bindings::size_row(a), bindings::size_row(b),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -189,6 +196,7 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -205,11 +213,13 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::ggrqf( size_row(a), size_row(b), size_column(a),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- &opt_size_work, -1 );
+ detail::ggrqf( bindings::size_row(a), bindings::size_row(b),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -243,6 +253,7 @@
             typename VectorTAUB, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -255,30 +266,36 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAUB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( size_row(b) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggrqf( size_row(a), size_row(b), size_column(a),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) );
+ BOOST_ASSERT( bindings::size(taua) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(taub) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(b),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::size_row(b) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(b)) );
+ return detail::ggrqf( bindings::size_row(a), bindings::size_row(b),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -292,6 +309,7 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );
@@ -308,11 +326,13 @@
             typename VectorTAUB >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
- detail::ggrqf( size_row(a), size_row(b), size_column(a),
- begin_value(a), stride_major(a), begin_value(taua),
- begin_value(b), stride_major(b), begin_value(taub),
- &opt_size_work, -1 );
+ detail::ggrqf( bindings::size_row(a), bindings::size_row(b),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(taua),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(taub), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, taua, b, taub, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -161,6 +161,7 @@
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace3< IWORK,
             TAU, WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -177,40 +178,49 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_tau( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a),
+ bindings::size_row(a), bindings::size_row(b) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(u) == 1 ||
+ bindings::stride_minor(u) == 1 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::size_row(b) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(b)) );
         BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
         BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
         BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >=
- min_size_tau( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a), size_row(a), size_row(b) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( size_row(b) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggsvp( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), tola, tolb, k, l,
- begin_value(u), stride_major(u), begin_value(v),
- stride_major(v), begin_value(q), stride_major(q),
- begin_value(work.select(fortran_int_t())),
- begin_value(work.select(real_type())),
- begin_value(work.select(real_type())) );
+ return detail::ggsvp( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_row(b), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), tola,
+ tolb, k, l, bindings::begin_value(u),
+ bindings::stride_major(u), bindings::begin_value(v),
+ bindings::stride_major(v), bindings::begin_value(q),
+ bindings::stride_major(q),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -226,12 +236,14 @@
             const char jobq, MatrixA& a, MatrixB& b, const real_type tola,
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
         bindings::detail::array<
- real_type > tmp_tau( min_size_tau( size_column(a) ) );
+ real_type > tmp_tau( min_size_tau( bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a), size_row(a), size_row(b) ) );
+ bindings::size_column(a), bindings::size_row(a),
+ bindings::size_row(b) ) );
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 workspace( tmp_iwork, tmp_tau, tmp_work ) );
     }
@@ -249,6 +261,7 @@
             const char jobq, MatrixA& a, MatrixB& b, const real_type tola,
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 minimal_workspace() );
     }
@@ -302,6 +315,7 @@
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace4< IWORK,
             RWORK, TAU, WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -318,43 +332,52 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_tau( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a),
+ bindings::size_row(a), bindings::size_row(b) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(u) == 1 ||
+ bindings::stride_minor(u) == 1 );
+ BOOST_ASSERT( bindings::size_minor(v) == 1 ||
+ bindings::stride_minor(v) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::size_row(b) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(b)) );
         BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
         BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
         BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >=
- min_size_tau( size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a), size_row(a), size_row(b) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(v) == 1 || stride_minor(v) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( size_row(b) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggsvp( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), tola, tolb, k, l,
- begin_value(u), stride_major(u), begin_value(v),
- stride_major(v), begin_value(q), stride_major(q),
- begin_value(work.select(fortran_int_t())),
- begin_value(work.select(real_type())),
- begin_value(work.select(value_type())),
- begin_value(work.select(value_type())) );
+ return detail::ggsvp( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_row(b), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), tola,
+ tolb, k, l, bindings::begin_value(u),
+ bindings::stride_major(u), bindings::begin_value(v),
+ bindings::stride_major(v), bindings::begin_value(q),
+ bindings::stride_major(q),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -370,14 +393,16 @@
             const char jobq, MatrixA& a, MatrixB& b, const real_type tola,
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array<
- value_type > tmp_tau( min_size_tau( size_column(a) ) );
+ value_type > tmp_tau( min_size_tau( bindings::size_column(a) ) );
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a), size_row(a), size_row(b) ) );
+ bindings::size_column(a), bindings::size_row(a),
+ bindings::size_row(b) ) );
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 workspace( tmp_iwork, tmp_rwork, tmp_tau, tmp_work ) );
     }
@@ -395,6 +420,7 @@
             const char jobq, MatrixA& a, MatrixB& b, const real_type tola,
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -166,6 +166,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorDL >::type >::type,
                 typename remove_const< typename value<
@@ -206,34 +207,42 @@
                 typename value< VectorDL >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(df) >= n );
- BOOST_ASSERT( size(dl) >= n-1 );
- BOOST_ASSERT( size(dlf) >= n-1 );
- BOOST_ASSERT( size(du) >= n-1 );
- BOOST_ASSERT( size(du2) >= n-2 );
- BOOST_ASSERT( size(duf) >= n-1 );
- BOOST_ASSERT( size(ipiv) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(df) >= n );
+ BOOST_ASSERT( bindings::size(dl) >= n-1 );
+ BOOST_ASSERT( bindings::size(dlf) >= n-1 );
+ BOOST_ASSERT( bindings::size(du) >= n-1 );
+ BOOST_ASSERT( bindings::size(du2) >= n-2 );
+ BOOST_ASSERT( bindings::size(duf) >= n-1 );
+ BOOST_ASSERT( bindings::size(ipiv) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
                 min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gtrfs( trans(), n, size_column(b), begin_value(dl),
- begin_value(d), begin_value(du), begin_value(dlf),
- begin_value(df), begin_value(duf), begin_value(du2),
- begin_value(ipiv), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( n >= 0 );
+ return detail::gtrfs( trans(), n, bindings::size_column(b),
+ bindings::begin_value(dl), bindings::begin_value(d),
+ bindings::begin_value(du), bindings::begin_value(dlf),
+ bindings::begin_value(df), bindings::begin_value(duf),
+ bindings::begin_value(du2), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -253,6 +262,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 min_size_iwork( n ) );
@@ -277,6 +287,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, minimal_workspace() );
     }
@@ -324,6 +335,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
                 typename remove_const< typename value<
@@ -360,33 +372,42 @@
                 typename value< VectorDL >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(df) >= n );
+ BOOST_ASSERT( bindings::size(dl) >= n-1 );
+ BOOST_ASSERT( bindings::size(dlf) >= n-1 );
+ BOOST_ASSERT( bindings::size(du) >= n-1 );
+ BOOST_ASSERT( bindings::size(du2) >= n-2 );
+ BOOST_ASSERT( bindings::size(duf) >= n-1 );
+ BOOST_ASSERT( bindings::size(ipiv) >= n );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( n ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(df) >= n );
- BOOST_ASSERT( size(dl) >= n-1 );
- BOOST_ASSERT( size(dlf) >= n-1 );
- BOOST_ASSERT( size(du) >= n-1 );
- BOOST_ASSERT( size(du2) >= n-2 );
- BOOST_ASSERT( size(duf) >= n-1 );
- BOOST_ASSERT( size(ipiv) >= n );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gtrfs( trans(), n, size_column(b), begin_value(dl),
- begin_value(d), begin_value(du), begin_value(dlf),
- begin_value(df), begin_value(duf), begin_value(du2),
- begin_value(ipiv), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gtrfs( trans(), n, bindings::size_column(b),
+ bindings::begin_value(dl), bindings::begin_value(d),
+ bindings::begin_value(du), bindings::begin_value(dlf),
+ bindings::begin_value(df), bindings::begin_value(duf),
+ bindings::begin_value(du2), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -406,6 +427,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
         return invoke( n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
@@ -429,6 +451,7 @@
             const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b,
             MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr,
                 berr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -132,6 +132,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t n,
             const VectorDL& dl, const VectorD& d, const VectorDU& du,
             const VectorDU2& du2, const VectorIPIV& ipiv, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorDL >::type >::type,
                 typename remove_const< typename value<
@@ -148,18 +149,22 @@
                 typename value< VectorDL >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(dl) >= n-1 );
- BOOST_ASSERT( size(du) >= n-1 );
- BOOST_ASSERT( size(du2) >= n-2 );
- BOOST_ASSERT( size(ipiv) >= n );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gttrs( trans(), n, size_column(b), begin_value(dl),
- begin_value(d), begin_value(du), begin_value(du2),
- begin_value(ipiv), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(dl) >= n-1 );
+ BOOST_ASSERT( bindings::size(du) >= n-1 );
+ BOOST_ASSERT( bindings::size(du2) >= n-2 );
+ BOOST_ASSERT( bindings::size(ipiv) >= n );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ return detail::gttrs( trans(), n, bindings::size_column(b),
+ bindings::begin_value(dl), bindings::begin_value(d),
+ bindings::begin_value(du), bindings::begin_value(du2),
+ bindings::begin_value(ipiv), bindings::begin_value(b),
+ bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,7 @@
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -114,26 +115,33 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(bb) == 1 || stride_minor(bb) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(bb) == 1 ||
+ bindings::stride_minor(bb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb,
+ uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' );
- return detail::hbgst( vect, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(x), stride_major(x),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hbgst( vect, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb,
+ uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(bb),
+ bindings::stride_major(bb), bindings::begin_value(x),
+ bindings::stride_major(x),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -146,11 +154,12 @@
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( vect, ab, bb, x, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -164,6 +173,7 @@
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( vect, ab, bb, x, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
             typename MatrixQ, typename WORK >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
@@ -110,23 +111,28 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(d) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
- return detail::hbtrd( vect, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(d),
- begin_value(e), begin_value(q), stride_major(q),
- begin_value(work.select(value_type())) );
+ return detail::hbtrd( vect, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(q),
+ bindings::stride_major(q),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -140,9 +146,10 @@
             typename MatrixQ >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
     }
 
@@ -157,6 +164,7 @@
             typename MatrixQ >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( vect, ab, d, e, q, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -99,17 +99,20 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hecon( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv), anorm, rcond,
- begin_value(work.select(value_type())) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hecon( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv), anorm, rcond,
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -122,9 +125,10 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, ipiv, anorm, rcond, workspace( tmp_work ) );
     }
 
@@ -138,6 +142,7 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, ipiv, anorm, rcond, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,21 +96,25 @@
     template< typename MatrixA, typename MatrixB >
     static std::ptrdiff_t invoke( const fortran_int_t itype, MatrixA& a,
             const MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hegst( itype, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hegst( itype, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -108,6 +108,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -125,36 +126,42 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(af) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::herfs( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(af),
- stride_major(af), begin_value(ipiv), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(af) == 1 ||
+ bindings::stride_minor(af) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(af) >= std::max<
+ std::ptrdiff_t >(1,bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::herfs( uplo(), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(af),
+ bindings::stride_major(af), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -170,11 +177,12 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -192,6 +200,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
             typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
@@ -109,21 +110,25 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(d) >= size_column(a) );
- BOOST_ASSERT( size(tau) >= size_column(a)-1 );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work());
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hetrd( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work());
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hetrd( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -137,6 +142,7 @@
             typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work() );
         return invoke( a, d, e, tau, workspace( tmp_work ) );
@@ -153,11 +159,13 @@
             typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         value_type opt_size_work;
- detail::hetrd( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tau), &opt_size_work, -1 );
+ detail::hetrd( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(tau), &opt_size_work, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( a, d, e, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,18 +96,22 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work());
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hetrf( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work());
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hetrf( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -120,6 +124,7 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work() );
         return invoke( a, ipiv, workspace( tmp_work ) );
@@ -135,6 +140,7 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, ipiv, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,18 +96,21 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hetri( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- begin_value(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hetri( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -120,9 +123,10 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, ipiv, workspace( tmp_work ) );
     }
 
@@ -136,6 +140,7 @@
     template< typename MatrixA, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, ipiv, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,24 +96,28 @@
     template< typename MatrixA, typename VectorIPIV, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::hetrs( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::hetrs( uplo(), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -154,6 +154,7 @@
             MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai,
             VectorBETA& beta, MatrixQ& q, MatrixZ& z, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
@@ -178,32 +179,38 @@
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixH >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHAR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHAI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size_column(h) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
         BOOST_ASSERT( job == 'E' || job == 'S' );
- BOOST_ASSERT( size(alphar) >= size_column(h) );
- BOOST_ASSERT( size(beta) >= size_column(h) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(h) ));
- BOOST_ASSERT( size_column(h) >= 0 );
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hgeqz( job, compq, compz, size_column(h), ilo,
- size_column(h), begin_value(h), stride_major(h),
- begin_value(t), stride_major(t), begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(q),
- stride_major(q), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::hgeqz( job, compq, compz, bindings::size_column(h),
+ ilo, bindings::size_column(h), bindings::begin_value(h),
+ bindings::stride_major(h), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(alphar),
+ bindings::begin_value(alphai), bindings::begin_value(beta),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -221,8 +228,9 @@
             MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai,
             VectorBETA& beta, MatrixQ& q, MatrixZ& z,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         return invoke( job, compq, compz, ilo, h, t, alphar, alphai, beta, q,
                 z, workspace( tmp_work ) );
     }
@@ -242,12 +250,15 @@
             MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai,
             VectorBETA& beta, MatrixQ& q, MatrixZ& z,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::hgeqz( job, compq, compz, size_column(h), ilo,
- size_column(h), begin_value(h), stride_major(h),
- begin_value(t), stride_major(t), begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(q),
- stride_major(q), begin_value(z), stride_major(z),
+ detail::hgeqz( job, compq, compz, bindings::size_column(h), ilo,
+ bindings::size_column(h), bindings::begin_value(h),
+ bindings::stride_major(h), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(alphar),
+ bindings::begin_value(alphai), bindings::begin_value(beta),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(z), bindings::stride_major(z),
                 &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
@@ -286,6 +297,7 @@
             const char compz, const fortran_int_t ilo, MatrixH& h,
             MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
             MatrixZ& z, detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
@@ -306,34 +318,40 @@
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixH >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size_column(h) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
         BOOST_ASSERT( job == 'E' || job == 'S' );
- BOOST_ASSERT( size(alpha) >= size_column(h) );
- BOOST_ASSERT( size(beta) >= size_column(h) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(h) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(h) ));
- BOOST_ASSERT( size_column(h) >= 0 );
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hgeqz( job, compq, compz, size_column(h), ilo,
- size_column(h), begin_value(h), stride_major(h),
- begin_value(t), stride_major(t), begin_value(alpha),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hgeqz( job, compq, compz, bindings::size_column(h),
+ ilo, bindings::size_column(h), bindings::begin_value(h),
+ bindings::stride_major(h), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -349,10 +367,11 @@
             const char compz, const fortran_int_t ilo, MatrixH& h,
             MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
             MatrixZ& z, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         return invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z,
                 workspace( tmp_work, tmp_rwork ) );
     }
@@ -370,15 +389,18 @@
             const char compz, const fortran_int_t ilo, MatrixH& h,
             MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
             MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         value_type opt_size_work;
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(h) ) );
- detail::hgeqz( job, compq, compz, size_column(h), ilo,
- size_column(h), begin_value(h), stride_major(h),
- begin_value(t), stride_major(t), begin_value(alpha),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(h) ) );
+ detail::hgeqz( job, compq, compz, bindings::size_column(h), ilo,
+ bindings::size_column(h), bindings::begin_value(h),
+ bindings::stride_major(h), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork) );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -97,14 +97,15 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::hpcon( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), anorm, rcond,
- begin_value(work.select(value_type())) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::hpcon( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv), anorm,
+ rcond, bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -117,9 +118,10 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) );
     }
 
@@ -133,6 +135,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, anorm, rcond, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -106,6 +106,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -123,29 +124,33 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::hprfs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::hprfs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -161,11 +166,12 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -183,6 +189,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -93,6 +93,7 @@
             typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e,
             VectorTAU& tau ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
@@ -102,15 +103,16 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(d) >= size_column(ap) );
- BOOST_ASSERT( size(tau) >= size_column(ap)-1 );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::hptrd( uplo(), size_column(ap), begin_value(ap),
- begin_value(d), begin_value(e), begin_value(tau) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(ap)-1 );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::hptrd( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(tau) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -89,12 +89,13 @@
     //
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::hptrf( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::hptrf( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -94,14 +94,16 @@
     template< typename MatrixAP, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::hptri( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), begin_value(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::hptri( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -114,9 +116,10 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, ipiv, workspace( tmp_work ) );
     }
 
@@ -130,6 +133,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,21 +96,24 @@
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::hptrs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(ipiv), begin_value(b),
- stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::hptrs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(ipiv), bindings::begin_value(b),
+ bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -152,6 +152,7 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
@@ -172,33 +173,38 @@
                 typename value< VectorIFAILL >::type >::type,
                 typename remove_const< typename value<
                 VectorIFAILR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSELECT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAILL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAILR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSELECT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILR >::value) );
+ BOOST_ASSERT( bindings::size(select) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(h), ?2 ));
+ BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size_column(h) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vl) == 1 ||
+ bindings::stride_minor(vl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vr) == 1 ||
+ bindings::stride_minor(vr) == 1 );
+ BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(h)) );
         BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
         BOOST_ASSERT( initv == 'N' || initv == 'U' );
         BOOST_ASSERT( mm >= m );
         BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(select) >= size_column(h) );
- BOOST_ASSERT( size(wi) >= size_column(h) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(h), ?2 ));
- BOOST_ASSERT( size(wr) >= size_column(h) );
- BOOST_ASSERT( size_column(h) >= 0 );
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(vl) == 1 || stride_minor(vl) == 1 );
- BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 1 );
- BOOST_ASSERT( stride_major(h) >= std::max< std::ptrdiff_t >(1,
- size_column(h)) );
- return detail::hsein( side, eigsrc, initv, begin_value(select),
- size_column(h), begin_value(h), stride_major(h),
- begin_value(wr), begin_value(wi), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr), mm, m,
- begin_value(work.select(real_type())), begin_value(ifaill),
- begin_value(ifailr) );
+ return detail::hsein( side, eigsrc, initv,
+ bindings::begin_value(select), bindings::size_column(h),
+ bindings::begin_value(h), bindings::stride_major(h),
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr), mm, m,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(ifaill), bindings::begin_value(ifailr) );
     }
 
     //
@@ -217,8 +223,9 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(h), ?2 ) );
+ bindings::size_column(h), ?2 ) );
         return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m,
                 ifaill, ifailr, workspace( tmp_work ) );
     }
@@ -239,6 +246,7 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m,
                 ifaill, ifailr, minimal_workspace() );
     }
@@ -276,6 +284,7 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr, detail::workspace2<
             WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorIFAILL >::type >::type,
                 typename remove_const< typename value<
@@ -292,34 +301,39 @@
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
                 MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAILL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAILR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILR >::value) );
+ BOOST_ASSERT( bindings::size(select) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size_column(h) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vl) == 1 ||
+ bindings::stride_minor(vl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vr) == 1 ||
+ bindings::stride_minor(vr) == 1 );
+ BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(h)) );
         BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
         BOOST_ASSERT( initv == 'N' || initv == 'U' );
         BOOST_ASSERT( mm >= m );
         BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(select) >= size_column(h) );
- BOOST_ASSERT( size(w) >= size_column(h) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(h) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(h) ));
- BOOST_ASSERT( size_column(h) >= 0 );
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(vl) == 1 || stride_minor(vl) == 1 );
- BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 1 );
- BOOST_ASSERT( stride_major(h) >= std::max< std::ptrdiff_t >(1,
- size_column(h)) );
- return detail::hsein( side, eigsrc, initv, begin_value(select),
- size_column(h), begin_value(h), stride_major(h),
- begin_value(w), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), mm, m,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())), begin_value(ifaill),
- begin_value(ifailr) );
+ return detail::hsein( side, eigsrc, initv,
+ bindings::begin_value(select), bindings::size_column(h),
+ bindings::begin_value(h), bindings::stride_major(h),
+ bindings::begin_value(w), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), mm, m,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(ifaill), bindings::begin_value(ifailr) );
     }
 
     //
@@ -338,10 +352,11 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         return invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m,
                 ifaill, ifailr, workspace( tmp_work, tmp_rwork ) );
     }
@@ -362,6 +377,7 @@
             const fortran_int_t mm, fortran_int_t& m,
             VectorIFAILL& ifaill, VectorIFAILR& ifailr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m,
                 ifaill, ifailr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,6 +143,7 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
@@ -155,22 +156,25 @@
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixH >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(h) );
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
         BOOST_ASSERT( job == 'E' || job == 'S' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(h) ));
- BOOST_ASSERT( size(wr) >= size_column(h) );
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hseqr( job, compz, size_column(h), ilo, ihi,
- begin_value(h), stride_major(h), begin_value(wr),
- begin_value(wi), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi,
+ bindings::begin_value(h), bindings::stride_major(h),
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -186,8 +190,9 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         return invoke( job, compz, ilo, ihi, h, wr, wi, z,
                 workspace( tmp_work ) );
     }
@@ -205,6 +210,7 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( job, compz, ilo, ihi, h, wr, wi, z,
                 minimal_workspace() );
     }
@@ -239,6 +245,7 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorW& w, MatrixZ& z, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
@@ -247,20 +254,23 @@
                 typename value< MatrixH >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixH >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(h) ));
+ BOOST_ASSERT( bindings::size_minor(h) == 1 ||
+ bindings::stride_minor(h) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
         BOOST_ASSERT( job == 'E' || job == 'S' );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(h) ));
- BOOST_ASSERT( size_minor(h) == 1 || stride_minor(h) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hseqr( job, compz, size_column(h), ilo, ihi,
- begin_value(h), stride_major(h), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi,
+ bindings::begin_value(h), bindings::stride_major(h),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
     }
 
     //
@@ -274,8 +284,9 @@
     static std::ptrdiff_t invoke( const char job, const char compz,
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(h) ) );
+ bindings::size_column(h) ) );
         return invoke( job, compz, ilo, ihi, h, w, z, workspace( tmp_work ) );
     }
 
@@ -290,6 +301,7 @@
     static std::ptrdiff_t invoke( const char job, const char compz,
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixH& h, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( job, compz, ilo, ihi, h, w, z, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -134,6 +134,7 @@
             typename MatrixY >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -158,29 +159,34 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixY >::value) );
- BOOST_ASSERT( size(d) >= size_column(a) );
- BOOST_ASSERT( size(e) >= size_column(a) );
- BOOST_ASSERT( size(taup) >= size_column(a) );
- BOOST_ASSERT( size(tauq) >= size_column(a) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( size_minor(y) == 1 || stride_minor(y) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(x) >= size_row(a) );
- BOOST_ASSERT( stride_major(y) >= size_column(a) );
- return detail::labrd( size_row(a), size_column(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(d),
- begin_value(e), begin_value(tauq), begin_value(taup),
- begin_value(x), stride_major(x), begin_value(y),
- stride_major(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::size_minor(y) == 1 ||
+ bindings::stride_minor(y) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::stride_major(y) >= bindings::size_column(a) );
+ return detail::labrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(tauq),
+ bindings::begin_value(taup), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(y),
+ bindings::stride_major(y) );
     }
 
 };
@@ -205,6 +211,7 @@
             typename MatrixY >
     static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
             VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -225,31 +232,36 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAUP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixY >::value) );
- BOOST_ASSERT( size(d) >= size_column(a) );
- BOOST_ASSERT( size(e) >= size_column(a) );
- BOOST_ASSERT( size(taup) >= size_column(a) );
- BOOST_ASSERT( size(tauq) >= size_column(a) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( size_minor(y) == 1 || stride_minor(y) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- BOOST_ASSERT( stride_major(y) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::labrd( size_row(a), size_column(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(d),
- begin_value(e), begin_value(tauq), begin_value(taup),
- begin_value(x), stride_major(x), begin_value(y),
- stride_major(y) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::size_minor(y) == 1 ||
+ bindings::stride_minor(y) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ BOOST_ASSERT( bindings::stride_major(y) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::labrd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(tauq),
+ bindings::begin_value(taup), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(y),
+ bindings::stride_major(y) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -123,14 +123,18 @@
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, detail::workspace2< V,
             ISGN > work ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( n >= 1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
                 min_size_isgn( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_v( n ));
- return detail::lacon( n, begin_value(work.select(real_type())),
- begin_value(x), begin_value(work.select(fortran_int_t())),
- est, kase );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_v( n ));
+ BOOST_ASSERT( n >= 1 );
+ return detail::lacon( n,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(x),
+ bindings::begin_value(work.select(fortran_int_t())), est,
+ kase );
     }
 
     //
@@ -143,6 +147,7 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_v( min_size_v( n ) );
         bindings::detail::array<
                 fortran_int_t > tmp_isgn( min_size_isgn( n ) );
@@ -159,6 +164,7 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, x, est, kase, minimal_workspace() );
     }
 
@@ -198,11 +204,14 @@
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, detail::workspace1<
             V > work ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_v( n ));
         BOOST_ASSERT( n >= 1 );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_v( n ));
- return detail::lacon( n, begin_value(work.select(value_type())),
- begin_value(x), est, kase );
+ return detail::lacon( n,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(x), est, kase );
     }
 
     //
@@ -215,6 +224,7 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_v( min_size_v( n ) );
         return invoke( n, x, est, kase, workspace( tmp_v ) );
     }
@@ -229,6 +239,7 @@
     template< typename VectorX >
     static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
             real_type& est, fortran_int_t& kase, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, x, est, kase, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -110,6 +110,7 @@
             const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
             fortran_int_t& mout, MatrixNAB& nab, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -130,24 +131,26 @@
                 typename value< VectorNVAL >::type >::type,
                 typename remove_const< typename value<
                 MatrixNAB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorNVAL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixNAB >::value) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(e2) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( stride_major(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- stride_major(ab) ));
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- return detail::laebz( ijob, nitmax, n, stride_major(ab), minp, nbmin,
- abstol, reltol, pivmin, begin_value(d), begin_value(e),
- begin_value(e2), begin_value(nval), begin_value(ab),
- begin_value(c), mout, begin_value(nab),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorNVAL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixNAB >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(e2) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::stride_major(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::stride_major(ab) ));
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ return detail::laebz( ijob, nitmax, n, bindings::stride_major(ab),
+ minp, nbmin, abstol, reltol, pivmin, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(e2),
+ bindings::begin_value(nval), bindings::begin_value(ab),
+ bindings::begin_value(c), mout, bindings::begin_value(nab),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -167,10 +170,11 @@
             const real_type pivmin, const VectorD& d, const VectorE& e,
             const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
             fortran_int_t& mout, MatrixNAB& nab, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- stride_major(ab) ) );
+ bindings::stride_major(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( stride_major(ab) ) );
+ min_size_iwork( bindings::stride_major(ab) ) );
         return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin,
                 d, e, e2, nval, ab, c, mout, nab, workspace( tmp_work,
                 tmp_iwork ) );
@@ -193,6 +197,7 @@
             const real_type pivmin, const VectorD& d, const VectorE& e,
             const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
             fortran_int_t& mout, MatrixNAB& nab, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin,
                 d, e, e2, nval, ab, c, mout, nab, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,20 +133,25 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const real_type tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::larz( side, size_row(c), size_column(c), l,
- begin_value(v), stride(v), tau, begin_value(c),
- stride_major(c), begin_value(work.select(real_type())) );
+ return detail::larz( side, bindings::size_row(c),
+ bindings::size_column(c), l, bindings::begin_value(v),
+ bindings::stride(v), tau, bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -160,8 +165,9 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const real_type tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, l, v, tau, c, workspace( tmp_work ) );
     }
 
@@ -176,6 +182,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const real_type tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, l, v, tau, c, minimal_workspace() );
     }
 
@@ -211,20 +218,25 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const value_type tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorV >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::larz( side, size_row(c), size_column(c), l,
- begin_value(v), stride(v), tau, begin_value(c),
- stride_major(c), begin_value(work.select(value_type())) );
+ return detail::larz( side, bindings::size_row(c),
+ bindings::size_column(c), l, bindings::begin_value(v),
+ bindings::stride(v), tau, bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -238,8 +250,9 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const value_type tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, l, v, tau, c, workspace( tmp_work ) );
     }
 
@@ -254,6 +267,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t l,
             const VectorV& v, const value_type tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, l, v, tau, c, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -136,6 +136,7 @@
             typename MatrixW >
     static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a,
             VectorE& e, VectorTAU& tau, MatrixW& w ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -149,18 +150,21 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixW >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(w) == 1 || stride_minor(w) == 1 );
- BOOST_ASSERT( stride_major(a) >= (ERROR) );
- BOOST_ASSERT( stride_major(w) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::latrd( uplo(), size_column(a), nb, begin_value(a),
- stride_major(a), begin_value(e), begin_value(tau),
- begin_value(w), stride_major(w) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(w) == 1 ||
+ bindings::stride_minor(w) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= (ERROR) );
+ BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::latrd( uplo(), bindings::size_column(a), nb,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(e), bindings::begin_value(tau),
+ bindings::begin_value(w), bindings::stride_major(w) );
     }
 
 };
@@ -184,6 +188,7 @@
             typename MatrixW >
     static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a,
             VectorE& e, VectorTAU& tau, MatrixW& w ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -193,19 +198,22 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixW >::value) );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(w) == 1 || stride_minor(w) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(w) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::latrd( uplo(), size_column(a), nb, begin_value(a),
- stride_major(a), begin_value(e), begin_value(tau),
- begin_value(w), stride_major(w) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(w) == 1 ||
+ bindings::stride_minor(w) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::latrd( uplo(), bindings::size_column(a), nb,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(e), bindings::begin_value(tau),
+ bindings::begin_value(w), bindings::stride_major(w) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -138,6 +138,7 @@
     static std::ptrdiff_t invoke( const char uplo, const char normin,
             const MatrixA& a, VectorX& x, real_type& scale,
             VectorCNORM& cnorm ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -148,16 +149,20 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorCNORM >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorCNORM >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) );
+ BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a,
+ trans()) );
+ BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= ?MAX );
         BOOST_ASSERT( normin == 'Y' || normin == 'N' );
- BOOST_ASSERT( size(x) >= size_column_op(a, trans()) );
- BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= ?MAX );
- return detail::latrs( uplo, trans(), diag(), normin, size_column_op(a,
- trans()), begin_value(a), stride_major(a), begin_value(x),
- scale, begin_value(cnorm) );
+ return detail::latrs( uplo, trans(), diag(), normin,
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), scale,
+ bindings::begin_value(cnorm) );
     }
 
 };
@@ -181,22 +186,27 @@
     static std::ptrdiff_t invoke( const char uplo, const char normin,
             const MatrixA& a, VectorX& x, real_type& scale,
             VectorCNORM& cnorm ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorCNORM >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) );
+ BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a,
+ trans()) );
+ BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= ?MAX );
         BOOST_ASSERT( normin == 'Y' || normin == 'N' );
- BOOST_ASSERT( size(x) >= size_column_op(a, trans()) );
- BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= ?MAX );
- return detail::latrs( uplo, trans(), diag(), normin, size_column_op(a,
- trans()), begin_value(a), stride_major(a), begin_value(x),
- scale, begin_value(cnorm) );
+ return detail::latrs( uplo, trans(), diag(), normin,
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(x), scale,
+ bindings::begin_value(cnorm) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -128,24 +128,27 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= size_row(a) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::latrz( size_row(a), size_column(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::latrz( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -158,8 +161,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a) ) );
+ bindings::size_row(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -173,6 +177,7 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( a, tau, minimal_workspace() );
     }
 
@@ -203,24 +208,27 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(tau) >= size_row(a) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::latrz( size_row(a), size_column(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::latrz( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -233,8 +241,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a) ) );
+ bindings::size_row(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -248,6 +257,7 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( a, tau, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -94,6 +94,7 @@
     static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap,
             const VectorTAU& tau, MatrixQ& q, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorAP >::type >::type,
                 typename remove_const< typename value<
@@ -102,18 +103,21 @@
                 typename value< VectorAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_ASSERT( size(ap) >= size_column(q)*(size_column(q)+1)/2 );
- BOOST_ASSERT( size(tau) >= size_column(q)-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(q) ));
- BOOST_ASSERT( size_column(q) >= 0 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( stride_major(q) >= std::max< std::ptrdiff_t >(1,
- size_column(q)) );
- return detail::opgtr( uplo, size_column(q), begin_value(ap),
- begin_value(tau), begin_value(q), stride_major(q),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::size(ap) >=
+ bindings::size_column(q)*(bindings::size_column(q)+1)/2 );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(q)-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(q) ));
+ BOOST_ASSERT( bindings::size_column(q) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(q)) );
+ return detail::opgtr( uplo, bindings::size_column(q),
+ bindings::begin_value(ap), bindings::begin_value(tau),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -126,8 +130,9 @@
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
     static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap,
             const VectorTAU& tau, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(q) ) );
+ bindings::size_column(q) ) );
         return invoke( uplo, ap, tau, q, workspace( tmp_work ) );
     }
 
@@ -141,6 +146,7 @@
     template< typename VectorAP, typename VectorTAU, typename MatrixQ >
     static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap,
             const VectorTAU& tau, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, ap, tau, q, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -99,6 +99,7 @@
     static std::ptrdiff_t invoke( const char side, const char uplo,
             const VectorAP& ap, const VectorTAU& tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorAP >::type >::type,
                 typename remove_const< typename value<
@@ -107,19 +108,22 @@
                 typename value< VectorAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::opmtr( side, uplo, trans(), size_row(c),
- size_column(c), begin_value(ap), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())) );
+ return detail::opmtr( side, uplo, trans(), bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(ap),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -133,8 +137,9 @@
     static std::ptrdiff_t invoke( const char side, const char uplo,
             const VectorAP& ap, const VectorTAU& tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) );
     }
 
@@ -149,6 +154,7 @@
     static std::ptrdiff_t invoke( const char side, const char uplo,
             const VectorAP& ap, const VectorTAU& tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( side, uplo, ap, tau, c, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,20 +95,25 @@
     static std::ptrdiff_t invoke( const char vect, const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( m, n ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
         BOOST_ASSERT( k >= 0 );
         BOOST_ASSERT( m >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( m, n ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
         BOOST_ASSERT( vect == 'Q' || vect == 'P' );
- return detail::orgbr( vect, m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orgbr( vect, m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -122,6 +127,7 @@
     static std::ptrdiff_t invoke( const char vect, const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( m, n ) );
         return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) );
     }
@@ -137,9 +143,11 @@
     static std::ptrdiff_t invoke( const char vect, const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orgbr( vect, m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orgbr( vect, m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -94,20 +94,24 @@
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixA& a, const VectorTAU& tau, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(tau) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::orghr( n, ilo, ihi, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orghr( n, ilo, ihi, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -121,6 +125,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t n,
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixA& a, const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) );
@@ -137,9 +142,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t n,
             const fortran_int_t ilo, const fortran_int_t ihi,
             MatrixA& a, const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orghr( n, ilo, ihi, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orghr( n, ilo, ihi, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -93,20 +93,25 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( m ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
         BOOST_ASSERT( m >= 0 );
         BOOST_ASSERT( n >= m );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( m ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
- return detail::orglq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orglq( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -120,6 +125,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( m ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );
     }
@@ -135,9 +141,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orglq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orglq( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -93,19 +93,24 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
         BOOST_ASSERT( m >= 0 );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
- return detail::orgql( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orgql( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -119,6 +124,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );
     }
@@ -134,9 +140,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orgql( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orgql( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -92,22 +92,25 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size(tau) >= size(tau) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::orgqr( size_row(a), size_column(a), size(tau),
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::orgqr( bindings::size_row(a), bindings::size_column(a),
+ bindings::size(tau), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -120,8 +123,9 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, tau, workspace( tmp_work ) );
     }
 
@@ -135,9 +139,11 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orgqr( size_row(a), size_column(a), size(tau),
- begin_value(a), stride_major(a), begin_value(tau),
+ detail::orgqr( bindings::size_row(a), bindings::size_column(a),
+ bindings::size(tau), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
                 &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -93,20 +93,25 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( m ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
         BOOST_ASSERT( m >= 0 );
         BOOST_ASSERT( n >= m );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( m ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
- return detail::orgrq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orgrq( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -120,6 +125,7 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( m ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );
     }
@@ -135,9 +141,11 @@
     static std::ptrdiff_t invoke( const fortran_int_t m,
             const fortran_int_t n, const fortran_int_t k, MatrixA& a,
             const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         real_type opt_size_work;
- detail::orgrq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orgrq( m, n, k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( m, n, k, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -97,20 +97,25 @@
     template< typename MatrixA, typename VectorTAU, typename WORK >
     static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a,
             const VectorTAU& tau, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(tau) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::orgtr( uplo(), n, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::orgtr( uplo(), n, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -123,6 +128,7 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a,
             const VectorTAU& tau, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         return invoke( n, a, tau, workspace( tmp_work ) );
@@ -138,10 +144,12 @@
     template< typename MatrixA, typename VectorTAU >
     static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a,
             const VectorTAU& tau, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         real_type opt_size_work;
- detail::orgtr( uplo(), n, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::orgtr( uplo(), n, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( n, a, tau, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,6 +102,7 @@
     static std::ptrdiff_t invoke( const char vect, const char side,
             const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
             MatrixC& c, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -111,24 +112,29 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= std::min< std::ptrdiff_t >(?NQ,
+ k) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( k >= 0 );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= std::min< std::ptrdiff_t >(?NQ,k) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
         BOOST_ASSERT( vect == 'Q' || vect == 'P' );
- return detail::ormbr( vect, side, trans(), size_row(c),
- size_column(c), k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormbr( vect, side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -142,9 +148,10 @@
     static std::ptrdiff_t invoke( const char vect, const char side,
             const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
             MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -159,11 +166,14 @@
     static std::ptrdiff_t invoke( const char vect, const char side,
             const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
             MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormbr( vect, side, trans(), size_row(c), size_column(c),
- k, begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormbr( vect, side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -104,6 +104,7 @@
             const fortran_int_t ihi, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -113,21 +114,25 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormhr( side, trans(), size_row(c), size_column(c), ilo,
- ihi, begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormhr( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), ilo, ihi, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -141,9 +146,10 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t ilo,
             const fortran_int_t ihi, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -158,11 +164,14 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t ilo,
             const fortran_int_t ihi, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormhr( side, trans(), size_row(c), size_column(c), ilo,
- ihi, begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormhr( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), ilo, ihi, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -110,23 +111,28 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ k) );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,k) );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormlq( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormlq( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -140,9 +146,10 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -157,11 +164,14 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormlq( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormlq( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -110,22 +111,26 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormql( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormql( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -139,9 +144,10 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -156,11 +162,14 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormql( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormql( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -110,22 +111,27 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= size(tau) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormqr( side, trans(), size_row(c), size_column(c),
- size(tau), begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormqr( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -138,9 +144,10 @@
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -154,11 +161,14 @@
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormqr( side, trans(), size_row(c), size_column(c),
- size(tau), begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormqr( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -110,23 +111,28 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ k) );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,k) );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormrq( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormrq( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -140,9 +146,10 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -157,11 +164,14 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormrq( side, trans(), size_row(c), size_column(c), k,
- begin_value(a), stride_major(a), begin_value(tau),
- begin_value(c), stride_major(c), &opt_size_work, -1 );
+ detail::ormrq( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,6 +102,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -111,23 +112,28 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ k) );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(tau) >= k );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,k) );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormrz( side, trans(), size_row(c), size_column(c), k,
- size_column_op(a, trans()), begin_value(a), stride_major(a),
- begin_value(tau), begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormrz( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::size_column_op(a,
+ trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -141,6 +147,7 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
@@ -158,12 +165,14 @@
     static std::ptrdiff_t invoke( const char side, const fortran_int_t k,
             const MatrixA& a, const VectorTAU& tau, MatrixC& c,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormrz( side, trans(), size_row(c), size_column(c), k,
- size_column_op(a, trans()), begin_value(a), stride_major(a),
- begin_value(tau), begin_value(c), stride_major(c),
- &opt_size_work, -1 );
+ detail::ormrz( side, trans(), bindings::size_row(c),
+ bindings::size_column(c), k, bindings::size_column_op(a,
+ trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         return invoke( side, k, a, tau, c, workspace( tmp_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -104,6 +104,7 @@
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -114,21 +115,25 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( side, bindings::size_row(c),
+ bindings::size_column(c) ));
+ BOOST_ASSERT( bindings::size_column(c) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_row(c) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(c)) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( side,
- size_row(c), size_column(c) ));
- BOOST_ASSERT( size_column(c) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_row(c) >= 0 );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,
- size_row(c)) );
- return detail::ormtr( side, uplo(), trans(), size_row(c),
- size_column(c), begin_value(a), stride_major(a),
- begin_value(tau), begin_value(c), stride_major(c),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ormtr( side, uplo(), trans(), bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
     }
 
     //
@@ -141,10 +146,11 @@
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
- size_row(c), size_column(c) ) );
+ bindings::size_row(c), bindings::size_column(c) ) );
         return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
@@ -158,12 +164,14 @@
     template< typename MatrixA, typename VectorTAU, typename MatrixC >
     static std::ptrdiff_t invoke( const char side, const MatrixA& a,
             const VectorTAU& tau, MatrixC& c, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
- detail::ormtr( side, uplo(), trans(), size_row(c),
- size_column(c), begin_value(a), stride_major(a),
- begin_value(tau), begin_value(c), stride_major(c),
+ detail::ormtr( side, uplo(), trans(), bindings::size_row(c),
+ bindings::size_column(c), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(tau),
+ bindings::begin_value(c), bindings::stride_major(c),
                 &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -136,18 +136,22 @@
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, detail::workspace2< WORK,
             IWORK > work ) {
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbcon( uplo, size_column(ab), bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab), anorm, rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ return detail::pbcon( uplo, bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), anorm, rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -160,10 +164,11 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
         return invoke( uplo, ab, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -178,6 +183,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, ab, anorm, rcond, minimal_workspace() );
     }
 
@@ -217,18 +223,22 @@
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, detail::workspace2< WORK,
             RWORK > work ) {
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth_upper(ab)+1 );
- return detail::pbcon( uplo, size_column(ab), bandwidth_upper(ab),
- begin_value(ab), stride_major(ab), anorm, rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >=
+ bindings::bandwidth_upper(ab)+1 );
+ return detail::pbcon( uplo, bindings::size_column(ab),
+ bindings::bandwidth_upper(ab), bindings::begin_value(ab),
+ bindings::stride_major(ab), anorm, rcond,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -241,10 +251,11 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( uplo, ab, anorm, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -259,6 +270,7 @@
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, ab, anorm, rcond, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -134,18 +134,22 @@
     template< typename MatrixAB, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
             real_type& scond, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 VectorS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbequ( uplo(), size_column(ab), bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab), begin_value(s), scond,
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ return detail::pbequ( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(s), scond,
                 amax );
     }
 
@@ -169,14 +173,18 @@
     template< typename MatrixAB, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
             real_type& scond, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbequ( uplo(), size_column(ab), bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab), begin_value(s), scond,
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ return detail::pbequ( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(s), scond,
                 amax );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -153,6 +153,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -174,34 +175,42 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(afb) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::pbrfs( uplo(), size_column(ab), bandwidth(ab, uplo()),
- size_column(b), begin_value(ab), stride_major(ab),
- begin_value(afb), stride_major(afb), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(afb) == 1 ||
+ bindings::stride_minor(afb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::pbrfs( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::size_column(b),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(afb), bindings::stride_major(afb),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -216,11 +225,12 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
         return invoke( ab, afb, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -237,6 +247,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
     }
@@ -279,6 +290,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -296,34 +308,42 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(afb) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::pbrfs( uplo(), size_column(ab), bandwidth(ab, uplo()),
- size_column(b), begin_value(ab), stride_major(ab),
- begin_value(afb), stride_major(afb), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(afb) == 1 ||
+ bindings::stride_minor(afb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::pbrfs( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::size_column(b),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(afb), bindings::stride_major(afb),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -338,11 +358,12 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( ab, afb, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -359,6 +380,7 @@
     static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -118,14 +118,18 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( MatrixAB& ab ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbstf( uplo(), size_column(ab), bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ return detail::pbstf( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -118,14 +118,18 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( MatrixAB& ab ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbtrf( uplo(), size_column(ab), bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ return detail::pbtrf( uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -119,22 +119,27 @@
     template< typename MatrixAB, typename MatrixB >
     static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::pbtrs( uplo, size_column(ab), bandwidth(ab, uplo()),
- size_column(b), begin_value(ab), stride_major(ab),
- begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::pbtrs( uplo, bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::size_column(b),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -124,19 +124,23 @@
     template< typename VectorA, typename MatrixB >
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             const VectorA& a, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::trans_tag< VectorA, order >::type transr;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(a) >= n*(n+1)/2 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(a) >= n*(n+1)/2 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pftrs( transr(), uplo, n, size_column(b),
- begin_value(a), begin_value(b), stride_major(b) );
+ return detail::pftrs( transr(), uplo, n, bindings::size_column(b),
+ bindings::begin_value(a), bindings::begin_value(b),
+ bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -137,19 +137,21 @@
     template< typename MatrixA, typename WORK, typename IWORK >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::pocon( uplo(), size_column(a), begin_value(a),
- stride_major(a), anorm, rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::pocon( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), anorm,
+ rcond, bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -162,11 +164,12 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
         return invoke( a, anorm, rcond, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -180,6 +183,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, anorm, rcond, minimal_workspace() );
     }
@@ -219,19 +223,21 @@
     template< typename MatrixA, typename WORK, typename RWORK >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::pocon( uplo(), size_column(a), begin_value(a),
- stride_major(a), anorm, rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::pocon( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), anorm,
+ rcond, bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -244,11 +250,12 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, anorm, rcond, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -262,6 +269,7 @@
     template< typename MatrixA >
     static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm,
             real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, anorm, rcond, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -122,17 +122,20 @@
     template< typename MatrixA, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixA& a, VectorS& s,
             real_type& scond, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::poequ( size_column(a), begin_value(a), stride_major(a),
- begin_value(s), scond, amax );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::poequ( bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(s), scond, amax );
     }
 
 };
@@ -155,13 +158,16 @@
     template< typename MatrixA, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixA& a, VectorS& s,
             real_type& scond, real_type& amax ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::poequ( size_column(a), begin_value(a), stride_major(a),
- begin_value(s), scond, amax );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::poequ( bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(s), scond, amax );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -150,6 +150,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -171,34 +172,41 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(af) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::porfs( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(af),
- stride_major(af), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(af) == 1 ||
+ bindings::stride_minor(af) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(af) >= std::max<
+ std::ptrdiff_t >(1,bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::porfs( uplo(), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(af),
+ bindings::stride_major(af), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -213,11 +221,12 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
         return invoke( a, af, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -234,6 +243,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, af, b, x, ferr, berr, minimal_workspace() );
     }
@@ -276,6 +286,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -293,34 +304,41 @@
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(af) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::porfs( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(af),
- stride_major(af), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(af) == 1 ||
+ bindings::stride_minor(af) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(af) >= std::max<
+ std::ptrdiff_t >(1,bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::porfs( uplo(), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(af),
+ bindings::stride_major(af), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -335,11 +353,12 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
         return invoke( a, af, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -356,6 +375,7 @@
     static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         return invoke( a, af, b, x, ferr, berr, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -178,14 +178,16 @@
     //
     template< typename MatrixA >
     static std::ptrdiff_t invoke( MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::potrf( order(), uplo(), size_column(a), begin_value(a),
- stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::potrf( order(), uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -178,14 +178,16 @@
     //
     template< typename MatrixA >
     static std::ptrdiff_t invoke( MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::potri( order(), uplo(), size_column(a), begin_value(a),
- stride_major(a) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::potri( order(), uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -190,23 +190,27 @@
     //
     template< typename MatrixA, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixA& a, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::potrs( order(), uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
+ return detail::potrs( order(), uplo(), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -134,15 +134,17 @@
     template< typename MatrixAP, typename WORK, typename IWORK >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::ppcon( uplo(), size_column(ap), begin_value(ap), anorm,
- rcond, begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::ppcon( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), anorm, rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -155,11 +157,12 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
         return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_iwork ) );
     }
 
@@ -173,6 +176,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, anorm, rcond, minimal_workspace() );
     }
@@ -212,15 +216,17 @@
     template< typename MatrixAP, typename WORK, typename RWORK >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::ppcon( uplo(), size_column(ap), begin_value(ap), anorm,
- rcond, begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::ppcon( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), anorm, rcond,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -233,11 +239,12 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -251,6 +258,7 @@
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
             real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, anorm, rcond, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -130,15 +130,17 @@
     template< typename MatrixAP, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s,
             real_type& scond, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 VectorS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::ppequ( uplo(), size_column(ap), begin_value(ap),
- begin_value(s), scond, amax );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::ppequ( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(s), scond,
+ amax );
     }
 
 };
@@ -161,11 +163,13 @@
     template< typename MatrixAP, typename VectorS >
     static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s,
             real_type& scond, real_type& amax ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::ppequ( uplo(), size_column(ap), begin_value(ap),
- begin_value(s), scond, amax );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::ppequ( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(s), scond,
+ amax );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -148,6 +148,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
@@ -169,28 +170,32 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::pprfs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::pprfs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -205,11 +210,12 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
         return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -226,6 +232,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() );
     }
@@ -268,6 +275,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -285,28 +293,32 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::pprfs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::pprfs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -321,11 +333,12 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -342,6 +355,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -113,10 +113,12 @@
     //
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::pptrf( uplo(), size_column(ap), begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::pptrf( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -113,10 +113,12 @@
     //
     template< typename MatrixAP >
     static std::ptrdiff_t invoke( MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::pptri( uplo(), size_column(ap), begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::pptri( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -123,19 +123,22 @@
     //
     template< typename MatrixAP, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixAP& ap, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::pptrs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::pptrs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -127,6 +127,7 @@
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -135,18 +136,21 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::pteqr( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::pteqr( compz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -159,6 +163,7 @@
     template< typename VectorD, typename VectorE, typename MatrixZ >
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         return invoke( compz, n, d, e, z, workspace( tmp_work ) );
     }
@@ -173,6 +178,7 @@
     template< typename VectorD, typename VectorE, typename MatrixZ >
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( compz, n, d, e, z, minimal_workspace() );
     }
 
@@ -205,22 +211,26 @@
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::pteqr( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::pteqr( compz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -233,6 +243,7 @@
     template< typename VectorD, typename VectorE, typename MatrixZ >
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         return invoke( compz, n, d, e, z, workspace( tmp_work ) );
     }
@@ -247,6 +258,7 @@
     template< typename VectorD, typename VectorE, typename MatrixZ >
     static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
             VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( compz, n, d, e, z, minimal_workspace() );
     }
 

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,6 +145,7 @@
             const VectorE& e, const VectorDF& df, const VectorEF& ef,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -173,26 +174,33 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(df) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(ef) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(df) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(ef) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::ptrfs( n, size_column(b), begin_value(d),
- begin_value(e), begin_value(df), begin_value(ef),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())) );
+ return detail::ptrfs( n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(df), bindings::begin_value(ef),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -209,6 +217,7 @@
             const VectorE& e, const VectorDF& df, const VectorEF& ef,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
         return invoke( n, d, e, df, ef, b, x, ferr, berr,
                 workspace( tmp_work ) );
@@ -228,6 +237,7 @@
             const VectorE& e, const VectorDF& df, const VectorEF& ef,
             const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( n, d, e, df, ef, b, x, ferr, berr,
                 minimal_workspace() );
     }
@@ -265,6 +275,7 @@
             const VectorEF& ef, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -289,28 +300,36 @@
                 typename value< VectorE >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(df) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(ef) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( n ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( n ));
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(df) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(ef) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::ptrfs( uplo, n, size_column(b), begin_value(d),
- begin_value(e), begin_value(df), begin_value(ef),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::ptrfs( uplo, n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(df), bindings::begin_value(ef),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -327,6 +346,7 @@
             const VectorD& d, const VectorE& e, const VectorDF& df,
             const VectorEF& ef, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
         return invoke( uplo, n, d, e, df, ef, b, x, ferr, berr,
@@ -347,6 +367,7 @@
             const VectorD& d, const VectorE& e, const VectorDF& df,
             const VectorEF& ef, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         return invoke( uplo, n, d, e, df, ef, b, x, ferr, berr,
                 minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -126,6 +126,7 @@
     template< typename VectorD, typename VectorE, typename MatrixB >
     static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
             const VectorE& e, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -134,15 +135,18 @@
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pttrs( n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b) );
+ return detail::pttrs( n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };
@@ -165,18 +169,22 @@
     template< typename VectorD, typename VectorE, typename MatrixB >
     static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
             const VectorD& d, const VectorE& e, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorE >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
         BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pttrs( uplo, n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b) );
+ return detail::pttrs( uplo, n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(b), bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
             typename WORK >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -109,23 +110,30 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(bb) == 1 || stride_minor(bb) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(bb) == 1 ||
+ bindings::stride_minor(bb) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb,
+ uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' );
- return detail::sbgst( vect, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(x), stride_major(x),
- begin_value(work.select(real_type())) );
+ return detail::sbgst( vect, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb,
+ uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(bb),
+ bindings::stride_major(bb), bindings::begin_value(x),
+ bindings::stride_major(x),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -138,9 +146,10 @@
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( vect, ab, bb, x, workspace( tmp_work ) );
     }
 
@@ -154,6 +163,7 @@
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
             const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( vect, ab, bb, x, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -99,6 +99,7 @@
             typename MatrixQ, typename WORK >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -112,23 +113,28 @@
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( size(d) >= size_column(ab) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ab) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size_column(ab) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
+ bindings::stride_minor(ab) == 1 );
+ BOOST_ASSERT( bindings::size_minor(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
- return detail::sbtrd( vect, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(d),
- begin_value(e), begin_value(q), stride_major(q),
- begin_value(work.select(real_type())) );
+ return detail::sbtrd( vect, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(q),
+ bindings::stride_major(q),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -142,9 +148,10 @@
             typename MatrixQ >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
         return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
     }
 
@@ -159,6 +166,7 @@
             typename MatrixQ >
     static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
             VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         return invoke( vect, ab, d, e, q, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -137,17 +137,18 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::spcon( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), anorm, rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::spcon( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv), anorm,
+ rcond, bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -160,11 +161,12 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
         return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -179,6 +181,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, anorm, rcond, minimal_workspace() );
     }
@@ -219,14 +222,15 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, detail::workspace1<
             WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::spcon( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), anorm, rcond,
- begin_value(work.select(value_type())) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::spcon( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv), anorm,
+ rcond, bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -239,9 +243,10 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) );
     }
 
@@ -255,6 +260,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, anorm, rcond, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -149,6 +149,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
@@ -170,29 +171,33 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::sprfs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::sprfs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -208,11 +213,12 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
         return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
@@ -230,6 +236,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
@@ -273,6 +280,7 @@
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
             RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -290,29 +298,33 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::sprfs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
+ BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::sprfs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -328,11 +340,12 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
@@ -350,6 +363,7 @@
     static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
             const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
             VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -91,6 +91,7 @@
             typename VectorTAU >
     static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e,
             VectorTAU& tau ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
@@ -104,15 +105,16 @@
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( size(d) >= size_column(ap) );
- BOOST_ASSERT( size(tau) >= size_column(ap)-1 );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::sptrd( uplo(), size_column(ap), begin_value(ap),
- begin_value(d), begin_value(e), begin_value(tau) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(ap)-1 );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::sptrd( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(tau) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -115,12 +115,13 @@
     //
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::sptrf( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::sptrf( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv) );
     }
 
 };

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,14 +129,16 @@
     template< typename MatrixAP, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::sptri( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), begin_value(work.select(real_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::sptri( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(real_type())) );
     }
 
     //
@@ -149,9 +151,10 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, ipiv, workspace( tmp_work ) );
     }
 
@@ -165,6 +168,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, minimal_workspace() );
     }
@@ -196,14 +200,16 @@
     template< typename MatrixAP, typename VectorIPIV, typename WORK >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::sptri( uplo(), size_column(ap), begin_value(ap),
- begin_value(ipiv), begin_value(work.select(value_type())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::sptri( uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())) );
     }
 
     //
@@ -216,9 +222,10 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
         return invoke( ap, ipiv, workspace( tmp_work ) );
     }
 
@@ -232,6 +239,7 @@
     template< typename MatrixAP, typename VectorIPIV >
     static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv,
             optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         return invoke( ap, ipiv, minimal_workspace() );
     }

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -126,21 +126,24 @@
     template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
     static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
             MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAP >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(ipiv) >= size_column(ap) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_column(b) >= 0 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column(ap)) );
- return detail::sptrs( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(ipiv), begin_value(b),
- stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_column(b) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ap)) );
+ return detail::sptrs( uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(ipiv), bindings::begin_value(b),
+ bindings::stride_major(b) );
     }
 
 };

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 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -106,6 +106,7 @@
             fortran_int_t& m, fortran_int_t& nsplit, VectorW& w,
             VectorIBLOCK& iblock, VectorISPLIT& isplit, detail::workspace2<
             WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -118,24 +119,26 @@
                 typename value< VectorIBLOCK >::type >::type,
                 typename remove_const< typename value<
                 VectorISPLIT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIBLOCK >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISPLIT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIBLOCK >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISPLIT >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(isplit) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n ));
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( order == 'B' || order == 'E' );
         BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(isplit) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
         return detail::stebz( range, order, n, vl, vu, il, iu, abstol,
- begin_value(d), begin_value(e), m, nsplit, begin_value(w),
- begin_value(iblock), begin_value(isplit),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ bindings::begin_value(d), bindings::begin_value(e), m, nsplit,
+ bindings::begin_value(w), bindings::begin_value(iblock),
+ bindings::begin_value(isplit),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
     }
 
     //
@@ -154,6 +157,7 @@
             fortran_int_t& m, fortran_int_t& nsplit, VectorW& w,
             VectorIBLOCK& iblock, VectorISPLIT& isplit,
             minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::binding