|
|
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::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( n ) );
@@ -177,6 +181,7 @@
fortran_int_t& m, fortran_int_t& nsplit, VectorW& w,
VectorIBLOCK& iblock, VectorISPLIT& isplit,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m,
nsplit, w, iblock, isplit, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -139,6 +139,7 @@
static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixZ& z, 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<
@@ -147,23 +148,25 @@
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(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( compz, n ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( compz, n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stedc( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stedc( 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())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -176,6 +179,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(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -193,10 +197,12 @@
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;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stedc( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z), &opt_size_work, -1,
+ detail::stedc( compz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
&opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
@@ -243,31 +249,34 @@
static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixZ& z, detail::workspace3< WORK,
RWORK, 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<
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(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( compz, n ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( compz, n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stedc( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stedc( compz, n, bindings::begin_value(d),
+ bindings::begin_value(e), 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())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -280,6 +289,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< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
@@ -300,11 +310,13 @@
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;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::stedc( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z), &opt_size_work, -1,
+ detail::stedc( compz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
&opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -154,6 +154,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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<
@@ -166,29 +167,31 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n, jobz ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n, jobz ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n, jobz ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- jobz ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stegr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stegr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -206,6 +209,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( n,
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -229,12 +233,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stegr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::stegr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -295,6 +301,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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<
@@ -303,29 +310,31 @@
typename value< VectorD >::type >::type,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n, jobz ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n, jobz ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n, jobz ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- jobz ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stegr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stegr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -343,6 +352,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( n,
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -366,12 +376,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stegr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::stegr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,6 +143,7 @@
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, 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<
@@ -163,24 +164,28 @@
typename value< VectorIBLOCK >::type >::type,
typename remove_const< typename value<
VectorIFAIL >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( n >= 0 );
- 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())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::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( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(z) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::stein( n, begin_value(d), begin_value(e), m,
- begin_value(w), begin_value(iblock), begin_value(isplit),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ 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( bindings::stride_major(z) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( n >= 0 );
+ return detail::stein( n, bindings::begin_value(d),
+ bindings::begin_value(e), m, bindings::begin_value(w),
+ bindings::begin_value(iblock), bindings::begin_value(isplit),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -197,6 +202,7 @@
const VectorE& e, const fortran_int_t m, const VectorW& w,
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, 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 ) );
@@ -218,6 +224,7 @@
const VectorE& e, const fortran_int_t m, const VectorW& w,
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( n, d, e, m, w, iblock, isplit, z, ifail,
minimal_workspace() );
}
@@ -262,6 +269,7 @@
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, 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<
@@ -278,24 +286,28 @@
typename value< VectorIBLOCK >::type >::type,
typename remove_const< typename value<
VectorIFAIL >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( n >= 0 );
- 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())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::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( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(z) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::stein( n, begin_value(d), begin_value(e), m,
- begin_value(w), begin_value(iblock), begin_value(isplit),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ 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( bindings::stride_major(z) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( n >= 0 );
+ return detail::stein( n, bindings::begin_value(d),
+ bindings::begin_value(e), m, bindings::begin_value(w),
+ bindings::begin_value(iblock), bindings::begin_value(isplit),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -312,6 +324,7 @@
const VectorE& e, const fortran_int_t m, const VectorW& w,
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, 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 ) );
@@ -333,6 +346,7 @@
const VectorE& e, const fortran_int_t m, const VectorW& w,
const VectorIBLOCK& iblock, const VectorISPLIT& isplit,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( n, d, e, m, w, iblock, isplit, z, ifail,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stemr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -156,6 +156,7 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, 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<
@@ -168,29 +169,31 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n, jobz ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n, jobz ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n, jobz ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- jobz ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stemr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, m, begin_value(w), begin_value(z),
- stride_major(z), nzc, begin_value(isuppz), tryrac,
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stemr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), nzc, bindings::begin_value(isuppz),
+ tryrac, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -209,6 +212,7 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( n,
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -233,12 +237,14 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stemr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, m, begin_value(w), begin_value(z),
- stride_major(z), nzc, begin_value(isuppz), tryrac,
- &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::stemr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), nzc, bindings::begin_value(isuppz),
+ tryrac, &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -299,6 +305,7 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, 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<
@@ -307,29 +314,31 @@
typename value< VectorD >::type >::type,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= n );
+ BOOST_ASSERT( bindings::size(w) >= n );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( n, jobz ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( n, jobz ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= n );
- BOOST_ASSERT( size(w) >= n );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n, jobz ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- jobz ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stemr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, m, begin_value(w), begin_value(z),
- stride_major(z), nzc, begin_value(isuppz), tryrac,
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stemr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), nzc, bindings::begin_value(isuppz),
+ tryrac, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -348,6 +357,7 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( n,
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -372,12 +382,14 @@
fortran_int_t& m, VectorW& w, MatrixZ& z,
const fortran_int_t nzc, VectorISUPPZ& isuppz,
logical_t& tryrac, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stemr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, m, begin_value(w), begin_value(z),
- stride_major(z), nzc, begin_value(isuppz), tryrac,
- &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::stemr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), nzc, bindings::begin_value(isuppz),
+ tryrac, &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp 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,20 @@
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(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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(e) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::steqr( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::steqr( 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 +162,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(
$CALL_MIN_SIZE ) );
return invoke( compz, n, d, e, z, workspace( tmp_work ) );
@@ -174,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() );
}
@@ -206,22 +211,25 @@
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(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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(e) >= n-1 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::steqr( compz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::steqr( 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())) );
}
//
@@ -234,6 +242,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(
$CALL_MIN_SIZE ) );
return invoke( compz, n, d, e, z, workspace( tmp_work ) );
@@ -249,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/sterf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -85,15 +85,17 @@
template< typename VectorD, typename VectorE >
static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d,
VectorE& e ) {
+ 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( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- return detail::sterf( n, begin_value(d), begin_value(e) );
+ return detail::sterf( n, bindings::begin_value(d),
+ bindings::begin_value(e) );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,20 +140,23 @@
static std::ptrdiff_t invoke( const MatrixA& a, 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< MatrixA >::type uplo;
- BOOST_ASSERT( size(ipiv) >= size_column(a) );
- 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::sycon( uplo(), size_column(a), begin_value(a),
- stride_major(a), 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(a) );
+ 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::sycon( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv), anorm, rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -166,11 +169,12 @@
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< 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, ipiv, anorm, rcond, workspace( tmp_work,
tmp_iwork ) );
}
@@ -185,6 +189,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() );
}
@@ -225,17 +230,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::sycon( 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::sycon( 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())) );
}
//
@@ -248,9 +256,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 ) );
}
@@ -264,6 +273,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/sygst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -94,21 +94,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::sygst( 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::sygst( 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/syrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.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::data_side< MatrixA >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixA >::type >::type,
@@ -174,36 +175,42 @@
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(a) );
- 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::syrfs( 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(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(a) );
+ 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::syrfs( 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(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -219,11 +226,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< 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, ipiv, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -241,6 +249,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() );
}
@@ -284,6 +293,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,
@@ -301,36 +311,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::syrfs( 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::syrfs( 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())) );
}
//
@@ -346,11 +362,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 ) );
}
@@ -368,6 +385,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/sytrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -98,6 +98,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< MatrixA >::type >::type,
@@ -111,21 +112,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(real_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::sytrd( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- 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< 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(real_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::sytrd( 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(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -139,6 +144,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< real_type > tmp_work( min_size_work() );
return invoke( a, d, e, tau, workspace( tmp_work ) );
@@ -155,11 +161,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;
real_type opt_size_work;
- detail::sytrd( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(d), begin_value(e),
- begin_value(tau), &opt_size_work, -1 );
+ detail::sytrd( 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< real_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/sytrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -136,18 +136,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(real_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::sytrf( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- 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< VectorIPIV >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_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::sytrf( uplo(), 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())) );
}
//
@@ -160,6 +164,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< real_type > tmp_work( min_size_work() );
return invoke( a, ipiv, workspace( tmp_work ) );
@@ -175,10 +180,12 @@
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;
real_type opt_size_work;
- detail::sytrf( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv), &opt_size_work, -1 );
+ detail::sytrf( uplo(), 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 ) );
@@ -211,18 +218,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::sytrf( 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::sytrf( 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())) );
}
//
@@ -235,6 +246,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 ) );
@@ -250,10 +262,12 @@
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;
value_type opt_size_work;
- detail::sytrf( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv), &opt_size_work, -1 );
+ detail::sytrf( uplo(), 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/sytri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,18 +133,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(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::sytri( uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(ipiv),
- begin_value(work.select(real_type())) );
+ 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::sytri( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -157,9 +160,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< real_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
return invoke( a, ipiv, workspace( tmp_work ) );
}
@@ -173,6 +177,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() );
}
@@ -204,18 +209,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::sytri( 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::sytri( uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(ipiv),
+ bindings::begin_value(work.select(value_type())) );
}
//
@@ -228,9 +236,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 ) );
}
@@ -244,6 +253,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/sytrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -126,24 +126,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::sytrs( 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::sytrs( 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/tbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -142,21 +142,23 @@
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ 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) >= kd+1 );
BOOST_ASSERT( kd >= 0 );
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- 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) >= kd+1 );
- return detail::tbcon( norm, uplo(), diag(), size_column(ab), kd,
- begin_value(ab), stride_major(ab), rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::tbcon( norm, uplo(), diag(), bindings::size_column(ab),
+ kd, bindings::begin_value(ab), bindings::stride_major(ab),
+ rcond, bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -169,12 +171,13 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
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, kd, ab, rcond, workspace( tmp_work, tmp_iwork ) );
}
@@ -188,6 +191,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
return invoke( norm, kd, ab, rcond, minimal_workspace() );
@@ -229,21 +233,23 @@
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
+ 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) >= kd+1 );
BOOST_ASSERT( kd >= 0 );
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- 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) >= kd+1 );
- return detail::tbcon( norm, uplo(), diag(), size_column(ab), kd,
- begin_value(ab), stride_major(ab), rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::tbcon( norm, uplo(), diag(), bindings::size_column(ab),
+ kd, bindings::begin_value(ab), bindings::stride_major(ab),
+ rcond, bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -256,12 +262,13 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
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, kd, ab, rcond, workspace( tmp_work, tmp_rwork ) );
}
@@ -275,6 +282,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
return invoke( norm, kd, ab, rcond, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -156,6 +156,7 @@
const MatrixAB& ab, const MatrixB& b, const 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;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -174,30 +175,35 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::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(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(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) >= kd+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)) );
BOOST_ASSERT( kd >= 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(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= kd+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::tbrfs( uplo(), trans(), diag(), size_column(ab), kd,
- size_column(b), begin_value(ab), stride_major(ab),
- 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())) );
+ return detail::tbrfs( uplo(), trans(), diag(),
+ bindings::size_column(ab), kd, bindings::size_column(b),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ 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())) );
}
//
@@ -212,12 +218,13 @@
static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
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( kd, ab, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -234,6 +241,7 @@
static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() );
@@ -278,6 +286,7 @@
const MatrixAB& ab, const MatrixB& b, const 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;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -292,30 +301,35 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::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(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(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) >= kd+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)) );
BOOST_ASSERT( kd >= 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(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(ab) >= kd+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::tbrfs( uplo(), trans(), diag(), size_column(ab), kd,
- size_column(b), begin_value(ab), stride_major(ab),
- 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::tbrfs( uplo(), trans(), diag(),
+ bindings::size_column(ab), kd, bindings::size_column(b),
+ bindings::begin_value(ab), bindings::stride_major(ab),
+ 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())) );
}
//
@@ -330,12 +344,13 @@
static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
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( kd, ab, b, x, ferr, berr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -352,6 +367,7 @@
static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -133,6 +133,7 @@
template< typename MatrixAB, typename MatrixB >
static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::trans_tag< MatrixAB, order >::type trans;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
@@ -140,18 +141,22 @@
typename value< MatrixAB >::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_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) >= kd+1 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column_op(ab, trans())) );
BOOST_ASSERT( kd >= 0 );
- 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) >= kd+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_column_op(ab, trans())) );
- return detail::tbtrs( uplo(), trans(), diag(), size_column_op(ab,
- trans()), kd, size_column(b), begin_value(ab),
- stride_major(ab), begin_value(b), stride_major(b) );
+ return detail::tbtrs( uplo(), trans(), diag(),
+ bindings::size_column_op(ab, trans()), kd,
+ 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/tgevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -149,6 +149,7 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixS >::type >::type,
typename remove_const< typename value<
@@ -161,27 +162,33 @@
typename value< MatrixS >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(s) ));
+ BOOST_ASSERT( bindings::size_column(s) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(p) == 1 ||
+ bindings::stride_minor(p) == 1 );
+ BOOST_ASSERT( bindings::size_minor(s) == 1 ||
+ bindings::stride_minor(s) == 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(p) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(s)) );
+ BOOST_ASSERT( bindings::stride_major(s) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(s)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(s) ));
- BOOST_ASSERT( size_column(s) >= 0 );
- BOOST_ASSERT( size_minor(p) == 1 || stride_minor(p) == 1 );
- BOOST_ASSERT( size_minor(s) == 1 || stride_minor(s) == 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(p) >= std::max< std::ptrdiff_t >(1,
- size_column(s)) );
- BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,
- size_column(s)) );
- return detail::tgevc( side, howmny, begin_value(select),
- size_column(s), begin_value(s), stride_major(s),
- begin_value(p), stride_major(p), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr), mm, m,
- begin_value(work.select(real_type())) );
+ return detail::tgevc( side, howmny, bindings::begin_value(select),
+ bindings::size_column(s), bindings::begin_value(s),
+ bindings::stride_major(s), bindings::begin_value(p),
+ bindings::stride_major(p), 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())) );
}
//
@@ -197,8 +204,9 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(s) ) );
+ bindings::size_column(s) ) );
return invoke( side, howmny, select, s, p, vl, vr, mm, m,
workspace( tmp_work ) );
}
@@ -216,6 +224,7 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( side, howmny, select, s, p, vl, vr, mm, m,
minimal_workspace() );
}
@@ -251,6 +260,7 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixS >::type >::type,
typename remove_const< typename value<
@@ -263,30 +273,36 @@
typename value< MatrixS >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(s) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(s) ));
+ BOOST_ASSERT( bindings::size_column(s) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(p) == 1 ||
+ bindings::stride_minor(p) == 1 );
+ BOOST_ASSERT( bindings::size_minor(s) == 1 ||
+ bindings::stride_minor(s) == 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(p) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(s)) );
+ BOOST_ASSERT( bindings::stride_major(s) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(s)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(s) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(s) ));
- BOOST_ASSERT( size_column(s) >= 0 );
- BOOST_ASSERT( size_minor(p) == 1 || stride_minor(p) == 1 );
- BOOST_ASSERT( size_minor(s) == 1 || stride_minor(s) == 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(p) >= std::max< std::ptrdiff_t >(1,
- size_column(s)) );
- BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,
- size_column(s)) );
- return detail::tgevc( side, howmny, begin_value(select),
- size_column(s), begin_value(s), stride_major(s),
- begin_value(p), stride_major(p), 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())) );
+ return detail::tgevc( side, howmny, bindings::begin_value(select),
+ bindings::size_column(s), bindings::begin_value(s),
+ bindings::stride_major(s), bindings::begin_value(p),
+ bindings::stride_major(p), 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())) );
}
//
@@ -302,10 +318,11 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(s) ) );
+ bindings::size_column(s) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(s) ) );
+ bindings::size_column(s) ) );
return invoke( side, howmny, select, s, p, vl, vr, mm, m,
workspace( tmp_work, tmp_rwork ) );
}
@@ -323,6 +340,7 @@
const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
fortran_int_t& m, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( side, howmny, select, s, p, vl, vr, mm, m,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,6 +145,7 @@
static std::ptrdiff_t invoke( const logical_t wantq, const logical_t wantz,
MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
fortran_int_t& ifst, fortran_int_t& ilst ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
@@ -157,27 +158,32 @@
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_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_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::tgexc( wantq, wantz, 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), ifst, ilst,
- 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::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::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)) );
+ return detail::tgexc( wantq, wantz, 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), ifst,
+ ilst, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
};
@@ -203,6 +209,7 @@
MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
const fortran_int_t ifst, fortran_int_t& ilst,
detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > 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<
@@ -215,23 +222,29 @@
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_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::tgexc( wantq, wantz, 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), ifst, ilst );
+ 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)) );
+ return detail::tgexc( wantq, wantz, 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), ifst,
+ ilst );
}
//
@@ -247,6 +260,7 @@
MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
const fortran_int_t ifst, fortran_int_t& ilst,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
$SETUP_MIN_WORKARRAYS_POST
return invoke( wantq, wantz, a, b, q, z, ifst, ilst,
workspace( $TMP_WORKARRAYS ) );
@@ -265,6 +279,7 @@
MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
const fortran_int_t ifst, fortran_int_t& ilst,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
$OPT_WORKSPACE_FUNC
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -167,6 +167,7 @@
MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
real_type& pr, VectorDIF& dif, detail::workspace2< WORK,
IWORK > 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<
@@ -195,39 +196,47 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorDIF >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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( (is_mutable< VectorDIF >::value) );
- BOOST_ASSERT( size(alphai) >= size_column(a) );
- BOOST_ASSERT( size(alphar) >= size_column(a) );
- BOOST_ASSERT( size(select) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) );
+ BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(select) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( $CALL_MIN_SIZE ));
- 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_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::tgsen( ijob, wantq, wantz, begin_value(select),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(q),
- stride_major(q), begin_value(z), stride_major(z), m, pl, pr,
- begin_value(dif), begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ 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_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)) );
+ return detail::tgsen( ijob, wantq, wantz,
+ bindings::begin_value(select), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ 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), m, pl, pr,
+ bindings::begin_value(dif),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -246,6 +255,7 @@
VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
real_type& pr, VectorDIF& dif, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -270,14 +280,18 @@
VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
real_type& pr, VectorDIF& dif, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::tgsen( ijob, wantq, wantz, begin_value(select),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(q),
- stride_major(q), begin_value(z), stride_major(z), m, pl, pr,
- begin_value(dif), &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::tgsen( ijob, wantq, wantz, bindings::begin_value(select),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), 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), m, pl,
+ pr, bindings::begin_value(dif), &opt_size_work, -1,
+ &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -328,6 +342,7 @@
VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
fortran_int_t& m, real_type& pl, real_type& pr,
VectorDIF& dif, detail::workspace2< WORK, IWORK > 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<
@@ -348,37 +363,44 @@
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< 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( (is_mutable< VectorDIF >::value) );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(select) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(select) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( $CALL_MIN_SIZE ));
- 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_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::tgsen( ijob, wantq, wantz, begin_value(select),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alpha),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ 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_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)) );
+ return detail::tgsen( ijob, wantq, wantz,
+ bindings::begin_value(select), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ bindings::begin_value(q), bindings::stride_major(q),
+ bindings::begin_value(z), bindings::stride_major(z), m, pl,
+ pr, bindings::begin_value(dif),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -397,6 +419,7 @@
VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
fortran_int_t& m, real_type& pl, real_type& pr,
VectorDIF& dif, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -421,14 +444,18 @@
VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
fortran_int_t& m, real_type& pl, real_type& pr,
VectorDIF& dif, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::tgsen( ijob, wantq, wantz, begin_value(select),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alpha),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
- &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::tgsen( ijob, wantq, wantz, bindings::begin_value(select),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(z),
+ bindings::stride_major(z), m, pl, pr,
+ bindings::begin_value(dif), &opt_size_work, -1,
+ &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -164,6 +164,7 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, 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<
@@ -188,38 +189,46 @@
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< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::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< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::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(alpha) >= 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_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 == 'I' || jobq == 'N' );
BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' );
BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' );
- BOOST_ASSERT( size(alpha) >= 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_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::tgsja( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(a), k, l, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), tola, tolb,
- begin_value(alpha), begin_value(beta), begin_value(u),
- stride_major(u), begin_value(v), stride_major(v),
- begin_value(q), stride_major(q),
- begin_value(work.select(real_type())), ncycle );
+ return detail::tgsja( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_row(b), bindings::size_column(a), k, l,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), tola,
+ tolb, bindings::begin_value(alpha),
+ bindings::begin_value(beta), 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(real_type())), ncycle );
}
//
@@ -238,8 +247,9 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, 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( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta,
u, v, q, ncycle, workspace( tmp_work ) );
}
@@ -260,6 +270,7 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta,
u, v, q, ncycle, minimal_workspace() );
}
@@ -297,6 +308,7 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorALPHA >::type >::type,
typename remove_const< typename value<
@@ -317,38 +329,46 @@
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< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::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< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::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(alpha) >= 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_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 == 'I' || jobq == 'N' );
BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' );
BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' );
- BOOST_ASSERT( size(alpha) >= 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_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::tgsja( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(a), k, l, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), tola, tolb,
- begin_value(alpha), begin_value(beta), begin_value(u),
- stride_major(u), begin_value(v), stride_major(v),
- begin_value(q), stride_major(q),
- begin_value(work.select(value_type())), ncycle );
+ return detail::tgsja( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_row(b), bindings::size_column(a), k, l,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), tola,
+ tolb, bindings::begin_value(alpha),
+ bindings::begin_value(beta), 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(value_type())), ncycle );
}
//
@@ -367,8 +387,9 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, 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( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta,
u, v, q, ncycle, workspace( tmp_work ) );
}
@@ -389,6 +410,7 @@
const real_type tola, const real_type tolb, VectorALPHA& alpha,
VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q,
fortran_int_t& ncycle, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta,
u, v, q, ncycle, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -157,6 +157,7 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
detail::workspace2< WORK, IWORK > 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,30 +178,37 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorDIF >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDIF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( $CALL_MIN_SIZE ));
+ 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::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(a) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( $CALL_MIN_SIZE ));
- 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( size_minor(b) == 1 || stride_minor(b) == 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(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgsna( job, howmny, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), begin_value(s),
- begin_value(dif), mm, m,
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::tgsna( job, howmny, bindings::begin_value(select), n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(s), bindings::begin_value(dif), mm, m,
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -219,6 +227,7 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -243,15 +252,17 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( $CALL_MIN_SIZE ) );
- detail::tgsna( job, howmny, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), begin_value(s),
- begin_value(dif), mm, m, &opt_size_work, -1,
- begin_value(tmp_iwork) );
+ detail::tgsna( job, howmny, bindings::begin_value(select), n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(s), bindings::begin_value(dif), mm, m,
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m,
@@ -299,6 +310,7 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorS >::type >::type,
typename remove_const< typename value<
@@ -315,30 +327,37 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDIF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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(vl) == 1 ||
+ bindings::stride_minor(vl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vr) == 1 ||
+ bindings::stride_minor(vr) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 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(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgsna( job, howmny, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), begin_value(s),
- begin_value(dif), mm, m,
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::tgsna( job, howmny, bindings::begin_value(select), n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(s), bindings::begin_value(dif), mm, m,
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -357,6 +376,7 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -381,6 +401,7 @@
const MatrixVR& vr, VectorS& s, VectorDIF& dif,
const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -166,6 +166,7 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
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,
@@ -187,27 +188,36 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixF >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixF >::value) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column_op(a, trans()), size_column(b) ));
- 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( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( size_minor(d) == 1 || stride_minor(d) == 1 );
- BOOST_ASSERT( size_minor(e) == 1 || stride_minor(e) == 1 );
- BOOST_ASSERT( size_minor(f) == 1 || stride_minor(f) == 1 );
- return detail::tgsyl( trans(), ijob, size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(c),
- stride_major(c), begin_value(d), stride_major(d),
- begin_value(e), stride_major(e), begin_value(f),
- stride_major(f), scale, dif,
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixF >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ));
+ 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::size_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(c) == 1 ||
+ bindings::stride_minor(c) == 1 );
+ BOOST_ASSERT( bindings::size_minor(d) == 1 ||
+ bindings::stride_minor(d) == 1 );
+ BOOST_ASSERT( bindings::size_minor(e) == 1 ||
+ bindings::stride_minor(e) == 1 );
+ BOOST_ASSERT( bindings::size_minor(f) == 1 ||
+ bindings::stride_minor(f) == 1 );
+ return detail::tgsyl( trans(), ijob, bindings::size_column_op(a,
+ trans()), bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(d),
+ bindings::stride_major(d), bindings::begin_value(e),
+ bindings::stride_major(e), bindings::begin_value(f),
+ bindings::stride_major(f), scale, dif,
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -223,11 +233,13 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
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 ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column_op(a, trans()), size_column(b) ) );
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ) );
return invoke( ijob, a, b, c, d, e, f, scale, dif,
workspace( tmp_work, tmp_iwork ) );
}
@@ -245,17 +257,21 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column_op(a, trans()), size_column(b) ) );
- detail::tgsyl( trans(), ijob, size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(c),
- stride_major(c), begin_value(d), stride_major(d),
- begin_value(e), stride_major(e), begin_value(f),
- stride_major(f), scale, dif, &opt_size_work, -1,
- begin_value(tmp_iwork) );
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ) );
+ detail::tgsyl( trans(), ijob, bindings::size_column_op(a,
+ trans()), bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(d),
+ bindings::stride_major(d), bindings::begin_value(e),
+ bindings::stride_major(e), bindings::begin_value(f),
+ bindings::stride_major(f), scale, dif, &opt_size_work, -1,
+ bindings::begin_value(tmp_iwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( ijob, a, b, c, d, e, f, scale, dif,
@@ -302,6 +318,7 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
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,
@@ -323,27 +340,36 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixF >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixF >::value) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column_op(a, trans()), size_column(b) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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 );
- BOOST_ASSERT( size_minor(d) == 1 || stride_minor(d) == 1 );
- BOOST_ASSERT( size_minor(e) == 1 || stride_minor(e) == 1 );
- BOOST_ASSERT( size_minor(f) == 1 || stride_minor(f) == 1 );
- return detail::tgsyl( trans(), ijob, size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(c),
- stride_major(c), begin_value(d), stride_major(d),
- begin_value(e), stride_major(e), begin_value(f),
- stride_major(f), scale, dif,
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixF >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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( bindings::size_minor(d) == 1 ||
+ bindings::stride_minor(d) == 1 );
+ BOOST_ASSERT( bindings::size_minor(e) == 1 ||
+ bindings::stride_minor(e) == 1 );
+ BOOST_ASSERT( bindings::size_minor(f) == 1 ||
+ bindings::stride_minor(f) == 1 );
+ return detail::tgsyl( trans(), ijob, bindings::size_column_op(a,
+ trans()), bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(d),
+ bindings::stride_major(d), bindings::begin_value(e),
+ bindings::stride_major(e), bindings::begin_value(f),
+ bindings::stride_major(f), scale, dif,
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -359,11 +385,13 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
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(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column_op(a, trans()), size_column(b) ) );
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ) );
return invoke( ijob, a, b, c, d, e, f, scale, dif,
workspace( tmp_work, tmp_iwork ) );
}
@@ -381,17 +409,21 @@
const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d,
const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
value_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column_op(a, trans()), size_column(b) ) );
- detail::tgsyl( trans(), ijob, size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(c),
- stride_major(c), begin_value(d), stride_major(d),
- begin_value(e), stride_major(e), begin_value(f),
- stride_major(f), scale, dif, &opt_size_work, -1,
- begin_value(tmp_iwork) );
+ min_size_iwork( bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ) );
+ detail::tgsyl( trans(), ijob, bindings::size_column_op(a,
+ trans()), bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::stride_major(c), bindings::begin_value(d),
+ bindings::stride_major(d), bindings::begin_value(e),
+ bindings::stride_major(e), bindings::begin_value(f),
+ bindings::stride_major(f), scale, dif, &opt_size_work, -1,
+ bindings::begin_value(tmp_iwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( ijob, a, b, c, d, e, f, scale, dif,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -136,17 +136,19 @@
template< typename MatrixAP, typename WORK, typename IWORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ 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( norm == '1' || norm == 'O' || norm == 'I' );
- 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::tpcon( norm, uplo(), diag(), size_column(ap),
- begin_value(ap), rcond, begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::tpcon( norm, uplo(), diag(), bindings::size_column(ap),
+ bindings::begin_value(ap), rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -159,12 +161,13 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
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( norm, ap, rcond, workspace( tmp_work, tmp_iwork ) );
}
@@ -178,6 +181,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
return invoke( norm, ap, rcond, minimal_workspace() );
@@ -218,18 +222,19 @@
template< typename MatrixAP, typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ 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( norm == '1' || norm == 'O' || norm == 'I' );
- 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::tpcon( norm, uplo(), diag(), size_column(ap),
- begin_value(ap), rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::tpcon( norm, uplo(), diag(), bindings::size_column(ap),
+ bindings::begin_value(ap), rcond,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -242,12 +247,13 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
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( norm, ap, rcond, workspace( tmp_work, tmp_rwork ) );
}
@@ -261,6 +267,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
return invoke( norm, ap, rcond, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -150,6 +150,7 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const 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;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -168,27 +169,31 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::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::tprfs( uplo(), trans(), diag(), size_column(ap),
- size_column(b), begin_value(ap), 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< 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::tprfs( uplo(), trans(), diag(),
+ bindings::size_column(ap), bindings::size_column(b),
+ bindings::begin_value(ap), 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())) );
}
//
@@ -203,12 +208,13 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
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, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -225,6 +231,7 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
return invoke( ap, b, x, ferr, berr, minimal_workspace() );
@@ -268,6 +275,7 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const 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;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -282,27 +290,31 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::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::tprfs( uplo(), trans(), diag(), size_column(ap),
- size_column(b), begin_value(ap), 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< 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::tprfs( uplo(), trans(), diag(),
+ bindings::size_column(ap), bindings::size_column(b),
+ bindings::begin_value(ap), 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())) );
}
//
@@ -317,12 +329,13 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
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, b, x, ferr, berr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -339,6 +352,7 @@
static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
return invoke( ap, b, x, ferr, berr, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -118,12 +118,13 @@
//
template< typename MatrixAP >
static std::ptrdiff_t invoke( MatrixAP& ap ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( size_column(ap) >= 0 );
- return detail::tptri( uplo(), diag(), size_column(ap),
- begin_value(ap) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ return detail::tptri( uplo(), diag(), bindings::size_column(ap),
+ bindings::begin_value(ap) );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,21 +129,24 @@
//
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;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
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::tptrs( uplo(), trans(), diag(), 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::tptrs( uplo(), trans(), diag(),
+ 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/trcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -138,21 +138,23 @@
template< typename MatrixA, typename WORK, typename IWORK >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, detail::workspace2< WORK, IWORK > 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( 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::trcon( norm, uplo(), diag(), size_column(a),
- begin_value(a), stride_major(a), rcond,
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::trcon( norm, uplo(), diag(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), rcond,
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -165,12 +167,13 @@
template< typename MatrixA >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, 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(
- 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, rcond, workspace( tmp_work, tmp_iwork ) );
}
@@ -184,6 +187,7 @@
template< typename MatrixA >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, 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, rcond, minimal_workspace() );
@@ -224,21 +228,23 @@
template< typename MatrixA, typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, detail::workspace2< WORK, RWORK > 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( 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::trcon( norm, uplo(), diag(), size_column(a),
- begin_value(a), stride_major(a), rcond,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::trcon( norm, uplo(), diag(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), rcond,
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -251,12 +257,13 @@
template< typename MatrixA >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, 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< 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, rcond, workspace( tmp_work, tmp_rwork ) );
}
@@ -270,6 +277,7 @@
template< typename MatrixA >
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
real_type& rcond, 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, rcond, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,6 +145,7 @@
VectorSELECT& select, const MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
@@ -153,25 +154,29 @@
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSELECT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSELECT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(t) ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(t) ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trevc( side, howmny, begin_value(select),
- size_column(t), begin_value(t), stride_major(t),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), mm, m,
- begin_value(work.select(real_type())) );
+ return detail::trevc( side, howmny, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), 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())) );
}
//
@@ -187,8 +192,9 @@
VectorSELECT& select, const MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(t) ) );
+ bindings::size_column(t) ) );
return invoke( side, howmny, select, t, vl, vr, mm, m,
workspace( tmp_work ) );
}
@@ -206,6 +212,7 @@
VectorSELECT& select, const MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( side, howmny, select, t, vl, vr, mm, m,
minimal_workspace() );
}
@@ -240,6 +247,7 @@
const VectorSELECT& select, MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
@@ -248,28 +256,32 @@
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size_column(t) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(t) ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(t) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(t) ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trevc( side, howmny, begin_value(select),
- size_column(t), begin_value(t), stride_major(t),
- 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())) );
+ return detail::trevc( side, howmny, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), 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())) );
}
//
@@ -285,10 +297,11 @@
const VectorSELECT& select, MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(t) ) );
+ bindings::size_column(t) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(t) ) );
+ bindings::size_column(t) ) );
return invoke( side, howmny, select, t, vl, vr, mm, m,
workspace( tmp_work, tmp_rwork ) );
}
@@ -306,6 +319,7 @@
const VectorSELECT& select, MatrixT& t, MatrixVL& vl,
MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( side, howmny, select, t, vl, vr, mm, m,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,25 +129,29 @@
template< typename MatrixT, typename MatrixQ >
static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q,
fortran_int_t& ifst, fortran_int_t& ilst ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(t) ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ 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::stride_major(q) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
+ BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( compq == 'V' || compq == 'N' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(t) ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( stride_major(q) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- BOOST_ASSERT( stride_major(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trexc( compq, size_column(t), begin_value(t),
- stride_major(t), begin_value(q), stride_major(q), ifst, ilst,
- begin_value(work.select(real_type())) );
+ return detail::trexc( compq, bindings::size_column(t),
+ bindings::begin_value(t), bindings::stride_major(t),
+ bindings::begin_value(q), bindings::stride_major(q), ifst,
+ ilst, bindings::begin_value(work.select(real_type())) );
}
};
@@ -171,22 +175,27 @@
static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q,
const fortran_int_t ifst, const fortran_int_t ilst,
detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
MatrixQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ 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::stride_major(q) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
+ BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( compq == 'V' || compq == 'N' );
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( stride_major(q) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- BOOST_ASSERT( stride_major(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trexc( compq, size_column(t), begin_value(t),
- stride_major(t), begin_value(q), stride_major(q), ifst, ilst );
+ return detail::trexc( compq, bindings::size_column(t),
+ bindings::begin_value(t), bindings::stride_major(t),
+ bindings::begin_value(q), bindings::stride_major(q), ifst,
+ ilst );
}
//
@@ -200,6 +209,7 @@
static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q,
const fortran_int_t ifst, const fortran_int_t ilst,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
$SETUP_MIN_WORKARRAYS_POST
return invoke( compq, t, q, ifst, ilst, workspace( $TMP_WORKARRAYS ) );
}
@@ -215,6 +225,7 @@
static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q,
const fortran_int_t ifst, const fortran_int_t ilst,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
$OPT_WORKSPACE_FUNC
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -154,6 +154,7 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const 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;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
@@ -173,30 +174,36 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::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_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(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(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::trrfs( uplo(), trans(), diag(), size_column_op(a,
- trans()), size_column(b), begin_value(a), stride_major(a),
- 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< 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_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(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(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::trrfs( uplo(), trans(), diag(),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), 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())) );
}
//
@@ -211,13 +218,14 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
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;
typedef typename result_of::diag_tag< MatrixA >::type diag;
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, b, x, ferr, berr, workspace( tmp_work, tmp_iwork ) );
}
@@ -233,6 +241,7 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
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;
typedef typename result_of::diag_tag< MatrixA >::type diag;
@@ -277,6 +286,7 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const 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;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
@@ -292,30 +302,36 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::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_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(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(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::trrfs( uplo(), trans(), diag(), size_column_op(a,
- trans()), size_column(b), begin_value(a), stride_major(a),
- 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< 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_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(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(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::trrfs( uplo(), trans(), diag(),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), 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())) );
}
//
@@ -330,13 +346,14 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
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;
typedef typename result_of::diag_tag< MatrixA >::type diag;
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, b, x, ferr, berr, workspace( tmp_work, tmp_rwork ) );
}
@@ -352,6 +369,7 @@
static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
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;
typedef typename result_of::diag_tag< MatrixA >::type diag;
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -103,6 +103,7 @@
const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
fortran_int_t& m, real_type& s, real_type& sep,
detail::workspace1< WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
@@ -111,25 +112,28 @@
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixT >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_ASSERT( bindings::size(select) >= bindings::size_column(t) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(t) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ 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::stride_major(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( compq == 'V' || compq == 'N' );
BOOST_ASSERT( job == 'N' || job == 'E' || job == 'V' || job == 'B' );
- BOOST_ASSERT( size(select) >= size_column(t) );
- BOOST_ASSERT( size(w) >= size_column(t) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 1 );
- BOOST_ASSERT( stride_major(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trsen( job, compq, begin_value(select), size_column(t),
- begin_value(t), stride_major(t), begin_value(q),
- stride_major(q), begin_value(w), m, s, sep,
- begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::trsen( job, compq, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(w), m, s,
+ sep, bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -145,6 +149,7 @@
const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
fortran_int_t& m, real_type& s, real_type& sep,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( job, compq, select, t, q, w, m, s, sep,
@@ -164,11 +169,13 @@
const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w,
fortran_int_t& m, real_type& s, real_type& sep,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
- detail::trsen( job, compq, begin_value(select), size_column(t),
- begin_value(t), stride_major(t), begin_value(q),
- stride_major(q), begin_value(w), m, s, sep, &opt_size_work,
- -1 );
+ detail::trsen( job, compq, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(q),
+ bindings::stride_major(q), bindings::begin_value(w), m, s,
+ sep, &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( job, compq, select, t, q, w, m, s, sep,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -150,6 +150,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
detail::workspace2< WORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
@@ -166,27 +167,32 @@
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
VectorSEP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSEP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSEP >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
BOOST_ASSERT( mm >= m );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trsna( job, howmny, begin_value(select),
- size_column(t), begin_value(t), stride_major(t),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), begin_value(s), begin_value(sep), mm, m,
- begin_value(work), stride_major(work),
- begin_value(work.select(fortran_int_t())) );
+ return detail::trsna( job, howmny, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), bindings::begin_value(s),
+ bindings::begin_value(sep), mm, m,
+ bindings::begin_value(work), bindings::stride_major(work),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -203,6 +209,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -225,6 +232,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m,
minimal_workspace() );
}
@@ -269,6 +277,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
detail::workspace2< WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorS >::type >::type,
typename remove_const< typename value<
@@ -281,27 +290,32 @@
typename value< MatrixT >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSEP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSEP >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(t) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(t) == 1 ||
+ bindings::stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(t)) );
BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
BOOST_ASSERT( mm >= m );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(t) >= 0 );
- BOOST_ASSERT( size_minor(t) == 1 || stride_minor(t) == 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(t) >= std::max< std::ptrdiff_t >(1,
- size_column(t)) );
- return detail::trsna( job, howmny, begin_value(select),
- size_column(t), begin_value(t), stride_major(t),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), begin_value(s), begin_value(sep), mm, m,
- begin_value(work), stride_major(work),
- begin_value(work.select(real_type())) );
+ return detail::trsna( job, howmny, bindings::begin_value(select),
+ bindings::size_column(t), bindings::begin_value(t),
+ bindings::stride_major(t), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), bindings::begin_value(s),
+ bindings::begin_value(sep), mm, m,
+ bindings::begin_value(work), bindings::stride_major(work),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -318,6 +332,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
@@ -340,6 +355,7 @@
const MatrixVR& vr, VectorS& s, VectorSEP& sep,
const fortran_int_t mm, fortran_int_t& m,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
const fortran_int_t isgn, const fortran_int_t m,
const fortran_int_t n, const MatrixA& a, const MatrixB& b,
MatrixC& c, real_type& 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<
@@ -148,20 +149,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_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( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ m) );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= 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(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,m) );
BOOST_ASSERT( trana == 'N' || trana == 'T' || trana == 'C' );
BOOST_ASSERT( tranb == 'N' || tranb == 'T' || tranb == 'C' );
- return detail::trsyl( trana, tranb, isgn, m, n, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(c), stride_major(c), scale );
+ return detail::trsyl( trana, tranb, isgn, m, n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(c), bindings::stride_major(c), scale );
}
};
@@ -186,6 +194,7 @@
const fortran_int_t isgn, const fortran_int_t m,
const fortran_int_t n, const MatrixA& a, const MatrixB& b,
MatrixC& c, real_type& 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<
@@ -194,20 +203,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_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( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ m) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
+ m) );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= 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(c) == 1 || stride_minor(c) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,m) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(c) >= std::max< std::ptrdiff_t >(1,m) );
BOOST_ASSERT( trana == 'N' || trana == 'C' );
BOOST_ASSERT( tranb == 'N' || tranb == 'C' );
- return detail::trsyl( trana, tranb, isgn, m, n, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(c), stride_major(c), scale );
+ return detail::trsyl( trana, tranb, isgn, m, n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(c), bindings::stride_major(c), scale );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -183,15 +183,18 @@
//
template< typename MatrixA >
static std::ptrdiff_t invoke( MatrixA& a ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
- 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::trtri( order(), uplo(), diag(), 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::trtri( order(), uplo(), diag(),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a) );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -131,6 +131,7 @@
//
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;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
@@ -138,18 +139,22 @@
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(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::trtrs( uplo(), trans(), diag(), size_column_op(a,
- trans()), 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(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::trtrs( uplo(), trans(), diag(),
+ bindings::size_column_op(a, trans()),
+ 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/tzrzf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -129,24 +129,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(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= size_row(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::tzrzf( 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) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(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::tzrzf( 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())) );
}
//
@@ -159,6 +162,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 ) );
@@ -174,9 +178,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::tzrzf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::tzrzf( 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 ) );
@@ -209,24 +215,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(
- $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= size_row(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::tzrzf( 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) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(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::tzrzf( 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())) );
}
//
@@ -239,6 +248,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 ) );
@@ -254,9 +264,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::tzrzf( size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(tau), &opt_size_work, -1 );
+ detail::tzrzf( 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/ungbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,21 +95,24 @@
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(value_type())) >=
+ min_size_work( m, n ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= m );
BOOST_ASSERT( k >= 0 );
BOOST_ASSERT( m >= 0 );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( m,
- n ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= m );
BOOST_ASSERT( vect == 'Q' || vect == 'P' );
- return detail::ungbr( vect, m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::ungbr( vect, m, n, k, 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())) );
}
//
@@ -123,6 +126,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< value_type > tmp_work( min_size_work( m,
n ) );
return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) );
@@ -139,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;
value_type opt_size_work;
- detail::ungbr( vect, m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::ungbr( vect, m, n, k, 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( vect, m, n, k, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,20 +96,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(value_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(value_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::unghr( n, ilo, ihi, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::unghr( n, 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())) );
}
//
@@ -123,6 +127,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< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) );
@@ -139,9 +144,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;
value_type opt_size_work;
- detail::unghr( n, ilo, ihi, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::unghr( n, 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( n, ilo, ihi, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,20 +95,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(value_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(value_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::unglq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::unglq( m, n, k, 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())) );
}
//
@@ -122,6 +127,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< value_type > tmp_work( min_size_work( m ) );
return invoke( m, n, k, a, tau, workspace( tmp_work ) );
}
@@ -137,9 +143,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;
value_type opt_size_work;
- detail::unglq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::unglq( m, n, k, 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( m, n, k, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,19 +95,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(value_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(value_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::ungql( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::ungql( m, n, k, 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())) );
}
//
@@ -121,6 +126,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< value_type > tmp_work( min_size_work( n ) );
return invoke( m, n, k, a, tau, workspace( tmp_work ) );
}
@@ -136,9 +142,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;
value_type opt_size_work;
- detail::ungql( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::ungql( m, n, k, 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( m, n, k, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -94,22 +94,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(value_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::ungqr( size_row(a), size_column(a), size(tau),
- 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_ASSERT( bindings::size(tau) >= bindings::size(tau) );
+ BOOST_ASSERT( bindings::size(work.select(value_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::ungqr( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -122,8 +125,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< value_type > tmp_work( min_size_work(
- size_column(a) ) );
+ bindings::size_column(a) ) );
return invoke( a, tau, workspace( tmp_work ) );
}
@@ -137,9 +141,11 @@
template< typename MatrixA, typename VectorTAU >
static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
- detail::ungqr( size_row(a), size_column(a), size(tau),
- begin_value(a), stride_major(a), begin_value(tau),
+ detail::ungqr( 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< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,20 +95,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(value_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(value_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::ungrq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::ungrq( m, n, k, 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())) );
}
//
@@ -122,6 +127,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< value_type > tmp_work( min_size_work( m ) );
return invoke( m, n, k, a, tau, workspace( tmp_work ) );
}
@@ -137,9 +143,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;
value_type opt_size_work;
- detail::ungrq( m, n, k, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::ungrq( m, n, k, 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( m, n, k, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -99,21 +99,24 @@
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(value_type())) >=
+ min_size_work( side, m, n ));
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= n );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(tau) >= n-1 );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( side,
- m, n ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( stride_major(a) >= n );
- return detail::ungtr( uplo(), n, begin_value(a), stride_major(a),
- begin_value(tau), begin_value(work.select(value_type())),
- size(work.select(value_type())) );
+ return detail::ungtr( uplo(), n, 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())) );
}
//
@@ -126,6 +129,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< value_type > tmp_work( min_size_work( side,
m, n ) );
@@ -142,10 +146,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;
value_type opt_size_work;
- detail::ungtr( uplo(), n, begin_value(a), stride_major(a),
- begin_value(tau), &opt_size_work, -1 );
+ detail::ungtr( uplo(), n, 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( n, a, tau, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,24 +115,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(value_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(value_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::unmbr( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmbr( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -145,9 +151,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< value_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 ) );
}
@@ -162,11 +169,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;
value_type opt_size_work;
- detail::unmbr( 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::unmbr( 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< value_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/unmhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -106,6 +106,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,
@@ -115,21 +116,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(value_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(value_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::unmhr( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmhr( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -143,9 +148,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< 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, ilo, ihi, a, tau, c, workspace( tmp_work ) );
}
@@ -160,11 +166,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;
value_type opt_size_work;
- detail::unmhr( 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::unmhr( 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< value_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/unmlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,23 +115,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(value_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(value_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::unmlq( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmlq( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -144,9 +150,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< 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, k, a, tau, c, workspace( tmp_work ) );
}
@@ -161,11 +168,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;
value_type opt_size_work;
- detail::unmlq( 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::unmlq( 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< value_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/unmql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,22 +115,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(value_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(value_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::unmql( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmql( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -143,9 +148,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< 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, k, a, tau, c, workspace( tmp_work ) );
}
@@ -160,11 +166,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;
value_type opt_size_work;
- detail::unmql( 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::unmql( 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< value_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/unmqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,22 +115,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(value_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(value_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::unmqr( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmqr( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -142,9 +148,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< 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, a, tau, c, workspace( tmp_work ) );
}
@@ -158,11 +165,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;
value_type opt_size_work;
- detail::unmqr( 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::unmqr( 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< value_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/unmrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,23 +115,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(value_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(value_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::unmrq( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmrq( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -144,9 +150,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< 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, k, a, tau, c, workspace( tmp_work ) );
}
@@ -161,11 +168,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;
value_type opt_size_work;
- detail::unmrq( 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::unmrq( 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< value_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/unmrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,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,
@@ -114,23 +115,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(value_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(value_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::unmrz( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmrz( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -144,6 +150,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< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
@@ -161,12 +168,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;
value_type opt_size_work;
- detail::unmrz( 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::unmrz( 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< value_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/unmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -108,6 +108,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<
@@ -118,21 +119,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(value_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(value_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::unmtr( 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(value_type())),
- size(work.select(value_type())) );
+ return detail::unmtr( 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(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -145,10 +150,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< 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, a, tau, c, workspace( tmp_work ) );
}
@@ -162,12 +168,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;
value_type opt_size_work;
- detail::unmtr( 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::unmtr( 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< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,6 +96,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<
@@ -104,18 +105,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(value_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::upgtr( uplo, size_column(q), begin_value(ap),
- begin_value(tau), begin_value(q), stride_major(q),
- begin_value(work.select(value_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(value_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::upgtr( 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(value_type())) );
}
//
@@ -128,8 +132,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< value_type > tmp_work( min_size_work(
- size_column(q) ) );
+ bindings::size_column(q) ) );
return invoke( uplo, ap, tau, q, workspace( tmp_work ) );
}
@@ -143,6 +148,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/upmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -103,6 +103,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<
@@ -111,19 +112,21 @@
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(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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::upmtr( 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(value_type())) );
+ return detail::upmtr( 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(value_type())) );
}
//
@@ -137,6 +140,7 @@
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< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) );
@@ -153,6 +157,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/driver/cgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -84,6 +84,7 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
detail::workspace3< WORK, SWORK, 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<
@@ -92,32 +93,38 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( size(ipiv) >= stride_major(work) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- stride_major(work) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_swork(
- stride_major(work), size_column(b) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(work) >= 0 );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- return detail::cgesv( stride_major(work), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(work),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())), iter );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::stride_major(work) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::stride_major(work) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_swork( bindings::stride_major(work),
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(work) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ return detail::cgesv( bindings::stride_major(work),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(work),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())), iter );
}
//
@@ -132,12 +139,13 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< value_type > tmp_swork( min_size_swork(
- stride_major(work), size_column(b) ) );
+ bindings::stride_major(work), bindings::size_column(b) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- stride_major(work) ) );
+ bindings::stride_major(work) ) );
return invoke( a, ipiv, b, x, iter, workspace( tmp_work, tmp_swork,
tmp_rwork ) );
}
@@ -154,6 +162,7 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( a, ipiv, b, x, iter, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -86,6 +86,7 @@
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, detail::workspace3< WORK, SWORK,
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< MatrixA >::type >::type,
@@ -95,29 +96,35 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- stride_major(work) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_swork(
- stride_major(work), size_column(b) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(work) >= 0 );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- return detail::cposv( uplo(), stride_major(work), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(work), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())), iter );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::stride_major(work) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_swork( bindings::stride_major(work),
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(work) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ return detail::cposv( uplo(), bindings::stride_major(work),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(work),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())), iter );
}
//
@@ -130,13 +137,14 @@
template< typename MatrixA, typename MatrixB, typename MatrixX >
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, 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(
$CALL_MIN_SIZE ) );
bindings::detail::array< value_type > tmp_swork( min_size_swork(
- stride_major(work), size_column(b) ) );
+ bindings::stride_major(work), bindings::size_column(b) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- stride_major(work) ) );
+ bindings::stride_major(work) ) );
return invoke( a, b, x, iter, workspace( tmp_work, tmp_swork,
tmp_rwork ) );
}
@@ -151,6 +159,7 @@
template< typename MatrixA, typename MatrixB, typename MatrixX >
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
return invoke( a, b, x, iter, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -122,27 +122,31 @@
//
template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixAB& ab, VectorIPIV& ipiv, 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< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( size(ipiv) >= 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(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(ab)) );
- return detail::gbsv( size_column(ab), bandwidth_lower(ab),
- bandwidth_upper(ab), size_column(b), begin_value(ab),
- stride_major(ab), begin_value(ipiv), begin_value(b),
- stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ 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_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) >= 2 );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
+ return detail::gbsv( 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(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b) );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -165,6 +165,7 @@
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
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<
@@ -193,46 +194,54 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAFB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 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_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)) );
BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
equed == 'B' );
BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
- 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_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::gbsvx( fact, 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), equed, begin_value(r),
- begin_value(c), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), rcond, begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gbsvx( fact, 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),
+ equed, bindings::begin_value(r), bindings::begin_value(c),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -249,10 +258,11 @@
MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r,
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
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( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr,
berr, workspace( tmp_work, tmp_iwork ) );
}
@@ -271,6 +281,7 @@
MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r,
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr,
berr, minimal_workspace() );
}
@@ -316,6 +327,7 @@
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
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< VectorR >::type >::type,
typename remove_const< typename value<
@@ -340,46 +352,54 @@
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< MatrixAFB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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::bandwidth_lower(ab) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 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_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)) );
BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
equed == 'B' );
BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
- 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_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::gbsvx( fact, 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), equed, begin_value(r),
- begin_value(c), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), rcond, begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gbsvx( fact, 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),
+ equed, bindings::begin_value(r), bindings::begin_value(c),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -396,10 +416,11 @@
MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r,
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
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( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr,
berr, workspace( tmp_work, tmp_rwork ) );
}
@@ -418,6 +439,7 @@
MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r,
VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr,
berr, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -144,6 +144,7 @@
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorWR& wr, VectorWI& wi, MatrixVS& vs, detail::workspace2<
WORK, BWORK > 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<
@@ -156,29 +157,32 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) );
+ BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(wr) >= 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_minor(vs) == 1 ||
+ bindings::stride_minor(vs) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
- BOOST_ASSERT( size(wi) >= size_column(a) );
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a) ));
- BOOST_ASSERT( size(wr) >= size_column(a) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(vs) == 1 || stride_minor(vs) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gees( jobvs, sort, select, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(wr),
- begin_value(wi), begin_value(vs), stride_major(vs),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(bool())) );
+ return detail::gees( jobvs, sort, select, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), sdim,
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(vs), bindings::stride_major(vs),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -194,10 +198,11 @@
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorWR& wr, VectorWI& wi, MatrixVS& vs,
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< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvs, sort, select, a, sdim, wr, wi, vs,
workspace( tmp_work, tmp_bwork ) );
}
@@ -215,13 +220,15 @@
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorWR& wr, VectorWI& wi, MatrixVS& vs,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::gees( jobvs, sort, select, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(wr),
- begin_value(wi), begin_value(vs), stride_major(vs),
- &opt_size_work, -1, begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::gees( jobvs, sort, select, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), sdim,
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(vs), bindings::stride_major(vs),
+ &opt_size_work, -1, bindings::begin_value(tmp_bwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvs, sort, select, a, sdim, wr, wi, vs,
@@ -270,6 +277,7 @@
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorW& w, MatrixVS& vs, detail::workspace3< WORK, RWORK,
BWORK > 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<
@@ -278,30 +286,33 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ 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_minor(vs) == 1 ||
+ bindings::stride_minor(vs) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
- BOOST_ASSERT( size(w) >= size_column(a) );
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- 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_minor(vs) == 1 || stride_minor(vs) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::gees( jobvs, sort, select, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(w),
- begin_value(vs), stride_major(vs),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(bool())) );
+ return detail::gees( jobvs, sort, select, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), sdim,
+ bindings::begin_value(w), bindings::begin_value(vs),
+ bindings::stride_major(vs),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -315,12 +326,13 @@
static std::ptrdiff_t invoke( const char jobvs, const char sort,
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorW& w, MatrixVS& vs, 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) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvs, sort, select, a, sdim, w, vs,
workspace( tmp_work, tmp_rwork, tmp_bwork ) );
}
@@ -336,15 +348,18 @@
static std::ptrdiff_t invoke( const char jobvs, const char sort,
logical_t* select, MatrixA& a, fortran_int_t& sdim,
VectorW& w, MatrixVS& vs, 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) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::gees( jobvs, sort, select, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(w),
- begin_value(vs), stride_major(vs), &opt_size_work, -1,
- begin_value(tmp_rwork), begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::gees( jobvs, sort, select, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), sdim,
+ bindings::begin_value(w), bindings::begin_value(vs),
+ bindings::stride_major(vs), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvs, sort, select, a, sdim, w, vs,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -151,6 +151,7 @@
fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs,
real_type& rconde, real_type& rcondv, detail::workspace3< WORK,
IWORK, BWORK > 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<
@@ -163,35 +164,39 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) );
+ BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a), sense ));
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a), sense ));
+ BOOST_ASSERT( bindings::size(wr) >= 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_minor(vs) == 1 ||
+ bindings::stride_minor(vs) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(wi) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a), sense ));
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a), sense ));
- BOOST_ASSERT( size(wr) >= size_column(a) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(vs) == 1 || stride_minor(vs) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geesx( jobvs, sort, select, sense, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(wr),
- begin_value(wi), begin_value(vs), stride_major(vs), rconde,
- rcondv, begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())),
- begin_value(work.select(bool())) );
+ return detail::geesx( jobvs, sort, select, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), sdim, bindings::begin_value(wr),
+ bindings::begin_value(wi), bindings::begin_value(vs),
+ bindings::stride_major(vs), rconde, rcondv,
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -207,12 +212,13 @@
logical_t* select, const char sense, MatrixA& a,
fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs,
real_type& rconde, real_type& rcondv, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a), sense ) );
+ bindings::size_column(a), sense ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a), sense ) );
+ min_size_iwork( bindings::size_column(a), sense ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvs, sort, select, sense, a, sdim, wr, wi, vs,
rconde, rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) );
}
@@ -230,15 +236,17 @@
logical_t* select, const char sense, MatrixA& a,
fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs,
real_type& rconde, real_type& rcondv, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::geesx( jobvs, sort, select, sense, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(wr),
- begin_value(wi), begin_value(vs), stride_major(vs), rconde,
- rcondv, &opt_size_work, -1, &opt_size_iwork, -1,
- begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::geesx( jobvs, sort, select, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), sdim, bindings::begin_value(wr),
+ bindings::begin_value(wi), bindings::begin_value(vs),
+ bindings::stride_major(vs), rconde, rcondv, &opt_size_work,
+ -1, &opt_size_iwork, -1, bindings::begin_value(tmp_bwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -306,6 +314,7 @@
fortran_int_t& sdim, VectorW& w, MatrixVS& vs,
real_type& rconde, real_type& rcondv, detail::workspace3< WORK,
RWORK, BWORK > 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<
@@ -314,32 +323,35 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ 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), sense ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vs) == 1 ||
+ bindings::stride_minor(vs) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(w) >= size_column(a) );
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- 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), sense ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(vs) == 1 || stride_minor(vs) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geesx( jobvs, sort, select, sense, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(w),
- begin_value(vs), stride_major(vs), rconde, rcondv,
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(bool())) );
+ return detail::geesx( jobvs, sort, select, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), sdim, bindings::begin_value(w),
+ bindings::begin_value(vs), bindings::stride_major(vs), rconde,
+ rcondv, bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -354,12 +366,13 @@
logical_t* select, const char sense, MatrixA& a,
fortran_int_t& sdim, VectorW& w, MatrixVS& vs,
real_type& rconde, real_type& rcondv, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a), sense ) );
+ bindings::size_column(a), sense ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde,
rcondv, workspace( tmp_work, tmp_rwork, tmp_bwork ) );
}
@@ -376,16 +389,18 @@
logical_t* select, const char sense, MatrixA& a,
fortran_int_t& sdim, VectorW& w, MatrixVS& vs,
real_type& rconde, real_type& rcondv, 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) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::geesx( jobvs, sort, select, sense, size_column(a),
- begin_value(a), stride_major(a), sdim, begin_value(w),
- begin_value(vs), stride_major(vs), rconde, rcondv,
- &opt_size_work, -1, begin_value(tmp_rwork),
- begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::geesx( jobvs, sort, select, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), sdim, bindings::begin_value(w),
+ bindings::begin_value(vs), bindings::stride_major(vs), rconde,
+ rcondv, &opt_size_work, -1, bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -142,6 +142,7 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl,
MatrixVR& vr, 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<
@@ -158,28 +159,33 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobvl, jobvr, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(wr) >= 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_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(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(wi) >= size_column(a) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobvl,
- jobvr, size_column(a) ));
- BOOST_ASSERT( size(wr) >= size_column(a) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(wr), begin_value(wi),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::geev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -194,8 +200,9 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl,
MatrixVR& vr, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( jobvl,
- jobvr, size_column(a) ) );
+ jobvr, bindings::size_column(a) ) );
return invoke( jobvl, jobvr, a, wr, wi, vl, vr,
workspace( tmp_work ) );
}
@@ -212,11 +219,14 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl,
MatrixVR& vr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::geev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(wr), begin_value(wi),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), &opt_size_work, -1 );
+ detail::geev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(wr), bindings::begin_value(wi),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvl, jobvr, a, wr, wi, vl, vr,
@@ -256,6 +266,7 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr,
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<
@@ -268,29 +279,34 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::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( (bindings::is_mutable< MatrixA >::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_ASSERT( bindings::size(w) >= 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_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(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(w) >= 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_minor(vl) == 1 || stride_minor(vl) == 1 );
- BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(w), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::geev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -305,10 +321,11 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr,
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( jobvl, jobvr, a, w, vl, vr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -325,13 +342,16 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr,
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::geev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(w), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- &opt_size_work, -1, begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::geev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), &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( jobvl, jobvr, a, w, vl, vr, workspace( tmp_work,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -161,6 +161,7 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace2<
WORK, IWORK > 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<
@@ -189,14 +190,32 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorRCONDV >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorWI >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(rconde) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(rcondv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( sense, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( sense, jobvl, jobvr,
+ bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(wr) >= 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_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(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
balanc == 'B' );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' ||
@@ -205,28 +224,17 @@
jobvr == 'B' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(rconde) >= size_column(a) );
- BOOST_ASSERT( size(rcondv) >= size_column(a) );
- BOOST_ASSERT( size(wi) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( sense, size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( sense,
- jobvl, jobvr, size_column(a) ));
- BOOST_ASSERT( size(wr) >= size_column(a) );
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(wr),
- begin_value(wi), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), ilo, ihi,
- begin_value(scale), abnrm, begin_value(rconde),
- begin_value(rcondv), begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::geevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(wr),
+ bindings::begin_value(wi), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), ilo, ihi,
+ bindings::begin_value(scale), abnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -245,10 +253,11 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( sense,
- jobvl, jobvr, size_column(a) ) );
+ jobvl, jobvr, bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
return invoke( balanc, jobvl, jobvr, sense, a, wr, wi, vl, vr, ilo,
ihi, scale, abnrm, rconde, rcondv, workspace( tmp_work,
tmp_iwork ) );
@@ -270,16 +279,19 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
- detail::geevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(wr),
- begin_value(wi), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), ilo, ihi,
- begin_value(scale), abnrm, begin_value(rconde),
- begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_iwork) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
+ detail::geevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(wr),
+ bindings::begin_value(wi), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), ilo, ihi,
+ bindings::begin_value(scale), abnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( balanc, jobvl, jobvr, sense, a, wr, wi, vl, vr, ilo,
@@ -339,6 +351,7 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace2<
WORK, RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorSCALE >::type >::type,
typename remove_const< typename value<
@@ -359,13 +372,29 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::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< VectorSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::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< VectorSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(rconde) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(rcondv) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(w) >= 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( sense, 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_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(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(a)) );
BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
balanc == 'B' );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' ||
@@ -374,27 +403,16 @@
jobvr == 'B' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(rconde) >= size_column(a) );
- BOOST_ASSERT( size(rcondv) >= size_column(a) );
- BOOST_ASSERT( size(w) >= 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( sense,
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::geevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(w),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), ilo, ihi, begin_value(scale), abnrm,
- begin_value(rconde), begin_value(rcondv),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::geevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(w),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr), ilo,
+ ihi, bindings::begin_value(scale), abnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -413,10 +431,11 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work( sense,
- 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( balanc, jobvl, jobvr, sense, a, w, vl, vr, ilo, ihi,
scale, abnrm, rconde, rcondv, workspace( tmp_work,
tmp_rwork ) );
@@ -438,15 +457,18 @@
fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
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::geevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(w),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), ilo, ihi, begin_value(scale), abnrm,
- begin_value(rconde), begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::geevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(w),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr), ilo,
+ ihi, bindings::begin_value(scale), abnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ &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( balanc, jobvl, jobvr, sense, a, w, vl, vr, ilo, ihi,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -149,6 +149,7 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, 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<
@@ -173,34 +174,41 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(alphar) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= 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_minor(b) == 1 || stride_minor(b) == 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(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::gegv( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alphar), begin_value(alphai), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::gegv( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -217,8 +225,9 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, 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( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr,
workspace( tmp_work ) );
}
@@ -237,12 +246,15 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::gegv( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alphar), begin_value(alphai), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), &opt_size_work, -1 );
+ detail::gegv( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr,
@@ -280,6 +292,7 @@
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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<
@@ -300,36 +313,42 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= 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_minor(b) == 1 || stride_minor(b) == 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(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::gegv( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alpha), begin_value(beta), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gegv( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -344,10 +363,11 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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( jobvl, jobvr, a, b, alpha, beta, vl, vr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -364,14 +384,17 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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::gegv( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alpha), begin_value(beta), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- &opt_size_work, -1, begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::gegv( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ &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( jobvl, jobvr, a, b, alpha, beta, vl, vr,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,27 +102,31 @@
const char jobv, const char jobr, const char jobt,
const char jobp, MatrixA& a, const fortran_int_t lwork,
detail::workspace5< SVA, U, V, WORK, IWORK > work ) {
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(real_type())) >=
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_sva( $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(real_type())) >=
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_u( $CALL_MIN_SIZE ));
- BOOST_ASSERT( size(work.select(real_type())) >=
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_v( $CALL_MIN_SIZE ));
- 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( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gejsv( joba, jobu, jobv, jobr, jobt, jobp, size_row(a),
- size_column(a), begin_value(a), stride_major(a),
- begin_value(work.select(real_type())), begin_value(u),
- stride_major(u), begin_value(v), stride_major(v),
- begin_value(work.select(real_type())), lwork,
- begin_value(work.select(fortran_int_t())) );
+ 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::size_row(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
+ return detail::gejsv( joba, jobu, jobv, jobr, jobt, jobp,
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(v), bindings::stride_major(v),
+ bindings::begin_value(work.select(real_type())), lwork,
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -137,6 +141,7 @@
const char jobv, const char jobr, const char jobt,
const char jobp, MatrixA& a, const fortran_int_t lwork,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array<
real_type > tmp_sva( min_size_sva( $CALL_MIN_SIZE ) );
bindings::detail::array<
@@ -163,6 +168,7 @@
const char jobv, const char jobr, const char jobt,
const char jobp, MatrixA& a, const fortran_int_t lwork,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( joba, jobu, jobv, jobr, jobt, jobp, a, lwork,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -142,31 +142,37 @@
template< typename MatrixA, typename MatrixB, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, 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,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row_op(a, trans()), size_column_op(a, trans()),
- size_column(b) ));
- 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( size_row_op(a, trans()) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row_op(a, trans())) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,std::max<
- std::ptrdiff_t >(size_row_op(a, trans()),size_column_op(a,
- trans()))) );
- return detail::gels( trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), size_column(b), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- 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< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ));
+ 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::size_row_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ std::max< std::ptrdiff_t >(bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()))) );
+ return detail::gels( trans(), bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -179,10 +185,11 @@
template< typename MatrixA, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b,
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_row_op(a, trans()), size_column_op(a, trans()),
- size_column(b) ) );
+ bindings::size_row_op(a, trans()), bindings::size_column_op(a,
+ trans()), bindings::size_column(b) ) );
return invoke( a, b, workspace( tmp_work ) );
}
@@ -196,12 +203,14 @@
template< typename MatrixA, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
real_type opt_size_work;
- detail::gels( trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), size_column(b), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- &opt_size_work, -1 );
+ detail::gels( trans(), bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, workspace( tmp_work ) );
@@ -237,31 +246,37 @@
template< typename MatrixA, typename MatrixB, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, 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,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row_op(a, trans()), size_column_op(a, trans()),
- size_column(b) ));
- 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( size_row_op(a, trans()) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row_op(a, trans())) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,std::max<
- std::ptrdiff_t >(size_row_op(a, trans()),size_column_op(a,
- trans()))) );
- return detail::gels( trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), size_column(b), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- 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< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b) ));
+ 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::size_row_op(a, trans()) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row_op(a, trans())) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ std::max< std::ptrdiff_t >(bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()))) );
+ return detail::gels( trans(), bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -274,10 +289,11 @@
template< typename MatrixA, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b,
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_row_op(a, trans()), size_column_op(a, trans()),
- size_column(b) ) );
+ bindings::size_row_op(a, trans()), bindings::size_column_op(a,
+ trans()), bindings::size_column(b) ) );
return invoke( a, b, workspace( tmp_work ) );
}
@@ -291,12 +307,14 @@
template< typename MatrixA, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
value_type opt_size_work;
- detail::gels( trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), size_column(b), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- &opt_size_work, -1 );
+ detail::gels( trans(), bindings::size_row_op(a, trans()),
+ bindings::size_column_op(a, trans()),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -144,6 +144,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
detail::workspace2< WORK, IWORK > 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,9 +153,9 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -162,27 +163,33 @@
std::ptrdiff_t >( static_cast<std::ptrdiff_t>(std::log(
static_cast<real_type>(minmn)/static_cast<real_type>(smlsiz+
1))/std::log(2.0)) + 1, 0 );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( minmn, nlvl ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( minmn,
- smlsiz, nlvl, size_column(b) ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelsd( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank,
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( minmn, smlsiz, nlvl,
+ bindings::size_column(b) ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelsd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -196,6 +203,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -204,7 +212,7 @@
static_cast<real_type>(minmn)/static_cast<real_type>(smlsiz+
1))/std::log(2.0)) + 1, 0 );
bindings::detail::array< real_type > tmp_work( min_size_work( minmn,
- smlsiz, nlvl, size_column(b) ) );
+ smlsiz, nlvl, bindings::size_column(b) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn, nlvl ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work,
@@ -222,6 +230,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -232,10 +241,11 @@
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn, nlvl ) );
- detail::gelsd( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank, &opt_size_work,
- -1, begin_value(tmp_iwork) );
+ detail::gelsd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, &opt_size_work, -1, bindings::begin_value(tmp_iwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work,
@@ -285,13 +295,14 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
detail::workspace3< WORK, RWORK, IWORK > 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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -299,30 +310,37 @@
std::ptrdiff_t >( static_cast<std::ptrdiff_t>(std::log(
static_cast<real_type>(minmn)/static_cast<real_type>(smlsiz+
1))/std::log(2.0)) + 1, 0 );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( minmn, nlvl ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( minmn,
- smlsiz, nlvl, size_column(b) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a), minmn, size_column(b) ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelsd( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank,
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( minmn, smlsiz, nlvl,
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a), minmn,
+ bindings::size_column(b) ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelsd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -336,6 +354,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -344,9 +363,9 @@
static_cast<real_type>(minmn)/static_cast<real_type>(smlsiz+
1))/std::log(2.0)) + 1, 0 );
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a), minmn, size_column(b) ) );
+ bindings::size_column(a), minmn, bindings::size_column(b) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn,
- smlsiz, nlvl, size_column(b) ) );
+ smlsiz, nlvl, bindings::size_column(b) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn, nlvl ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work, tmp_rwork,
@@ -364,6 +383,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", "");
@@ -373,13 +393,15 @@
1))/std::log(2.0)) + 1, 0 );
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn,
- smlsiz, nlvl, size_column(b) ) );
+ smlsiz, nlvl, bindings::size_column(b) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn, nlvl ) );
- detail::gelsd( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank, &opt_size_work,
- -1, begin_value(tmp_rwork), begin_value(tmp_iwork) );
+ detail::gelsd( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, &opt_size_work, -1, bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work, tmp_rwork,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -141,6 +141,7 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
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,27 +150,33 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorS >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_ASSERT( size(s) >= 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), size_column(b) ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelss( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank,
- 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_ASSERT( bindings::size(s) >= 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), bindings::size_column(b) ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelss( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -183,8 +190,10 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_column(b) ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b) ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work ) );
}
@@ -199,11 +208,13 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::gelss( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank, &opt_size_work,
- -1 );
+ detail::gelss( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work ) );
@@ -242,36 +253,43 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- minmn ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a), size_column(b), minmn ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelss( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank,
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( minmn ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), bindings::size_column(b), minmn ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelss( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -285,10 +303,12 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_column(b), minmn ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), minmn ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
minmn ) );
return invoke( a, b, s, rcond, rank, workspace( tmp_work,
@@ -306,15 +326,17 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s,
const real_type rcond, fortran_int_t& rank,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
minmn ) );
- detail::gelss( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(s), rcond, rank, &opt_size_work,
- -1, begin_value(tmp_rwork) );
+ detail::gelss( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(s), rcond,
+ rank, &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, b, s, rcond, rank, workspace( tmp_work,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -142,29 +142,35 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorJPVT >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a), size_column(a), size_column(b) ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelsy( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(jpvt), rcond, rank,
- 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), bindings::size_column(b) ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelsy( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(jpvt), rcond,
+ rank, bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -178,8 +184,10 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_column(b) ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b) ) );
return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work ) );
}
@@ -194,11 +202,13 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::gelsy( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(jpvt), rcond, rank,
- &opt_size_work, -1 );
+ detail::gelsy( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(jpvt), rcond,
+ rank, &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work ) );
@@ -236,32 +246,38 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorJPVT >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a), size_column(b) ));
- 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,std::max<
- std::ptrdiff_t >(size_row(a),size_column(a))) );
- return detail::gelsy( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(jpvt), rcond, rank,
- 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) );
+ 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_row(a),
+ bindings::size_column(a), bindings::size_column(b) ));
+ 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,
+ std::max< std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a))) );
+ return detail::gelsy( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(jpvt), rcond,
+ rank, bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -275,10 +291,12 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_column(b) ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work,
tmp_rwork ) );
}
@@ -294,13 +312,15 @@
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt,
const real_type rcond, fortran_int_t& rank,
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::gelsy( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(jpvt), rcond, rank,
- &opt_size_work, -1, begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::gelsy( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(jpvt), rcond,
+ rank, &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, b, jpvt, rcond, rank, workspace( tmp_work,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,6 +143,7 @@
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, detail::workspace2< WORK,
IWORK > 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<
@@ -155,33 +156,40 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
integer_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( minmn ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), jobz, minmn ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 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(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' ||
jobz == 'N' );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( minmn ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a), size_column(a), jobz, minmn ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gesdd( jobz, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gesdd( jobz, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -195,10 +203,12 @@
typename MatrixVT >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
integer_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a), size_column(a), jobz, minmn ) );
+ bindings::size_row(a), bindings::size_column(a), jobz,
+ minmn ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn ) );
return invoke( jobz, a, s, u, vt, workspace( tmp_work, tmp_iwork ) );
@@ -215,6 +225,7 @@
typename MatrixVT >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobz, a, s, u, vt, minimal_workspace() );
}
@@ -264,6 +275,7 @@
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, detail::workspace3< WORK, RWORK,
IWORK > 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<
@@ -272,36 +284,43 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
integer_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( minmn ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( minmn, jobz ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), jobz, minmn ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 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(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' ||
jobz == 'N' );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( minmn ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( minmn,
- jobz ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a), jobz, minmn ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gesdd( jobz, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gesdd( jobz, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -315,10 +334,12 @@
typename MatrixVT >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
integer_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a), jobz, minmn ) );
+ bindings::size_row(a), bindings::size_column(a), jobz,
+ minmn ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn,
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -338,6 +359,7 @@
typename MatrixVT >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s,
MatrixU& u, MatrixVT& vt, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
integer_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
value_type opt_size_work;
@@ -345,11 +367,13 @@
jobz ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( minmn ) );
- detail::gesdd( jobz, size_row(a), size_column(a), begin_value(a),
- stride_major(a), begin_value(s), begin_value(u),
- stride_major(u), begin_value(vt), stride_major(vt),
- &opt_size_work, -1, begin_value(tmp_rwork),
- begin_value(tmp_iwork) );
+ detail::gesdd( jobz, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ &opt_size_work, -1, bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobz, a, s, u, vt, workspace( tmp_work, tmp_rwork,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -186,25 +186,29 @@
//
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) {
+ namespace bindings = ::boost::numeric::bindings;
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_STATIC_ASSERT( (is_mutable< VectorIPIV >::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::gesv( order(), 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< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ 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::gesv( order(), 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/driver/gesvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,6 +143,7 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
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<
@@ -155,30 +156,37 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
+ BOOST_ASSERT( bindings::size(s) >= 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_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(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' ||
jobu == 'N' );
BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' ||
jobvt == 'N' );
- BOOST_ASSERT( size(s) >= 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_minor(u) == 1 || stride_minor(u) == 1 );
- BOOST_ASSERT( size_minor(vt) == 1 || stride_minor(vt) == 1 );
- BOOST_ASSERT( size_row(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gesvd( jobu, jobvt, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::gesvd( jobu, jobvt, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -193,8 +201,9 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
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( jobu, jobvt, a, s, u, vt, workspace( tmp_work ) );
}
@@ -210,11 +219,14 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::gesvd( jobu, jobvt, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), &opt_size_work, -1 );
+ detail::gesvd( jobu, jobvt, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work ) );
@@ -253,6 +265,7 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
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<
@@ -261,35 +274,42 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVT >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVT >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
+ BOOST_ASSERT( bindings::size(s) >= std::min<
+ std::ptrdiff_t >(bindings::size_row(a),
+ bindings::size_column(a)) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( minmn ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), minmn ));
+ BOOST_ASSERT( bindings::size_column(a) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(a) == 1 ||
+ bindings::stride_minor(a) == 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(a) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_row(a)) );
BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' ||
jobu == 'N' );
BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' ||
jobvt == 'N' );
- BOOST_ASSERT( size(s) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(a)) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- minmn ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a), minmn ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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(a) >= 0 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(a)) );
- return detail::gesvd( jobu, jobvt, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gesvd( jobu, jobvt, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -304,10 +324,11 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a), minmn ) );
+ bindings::size_row(a), bindings::size_column(a), minmn ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
minmn ) );
return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work,
@@ -326,15 +347,18 @@
static std::ptrdiff_t invoke( const char jobu, const char jobvt,
MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a),
size_column(a) );
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
minmn ) );
- detail::gesvd( jobu, jobvt, size_row(a), size_column(a),
- begin_value(a), stride_major(a), begin_value(s),
- begin_value(u), stride_major(u), begin_value(vt),
- stride_major(vt), &opt_size_work, -1, begin_value(tmp_rwork) );
+ detail::gesvd( jobu, jobvt, bindings::size_row(a),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(s),
+ bindings::begin_value(u), bindings::stride_major(u),
+ bindings::begin_value(vt), bindings::stride_major(vt),
+ &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( jobu, jobvt, a, s, u, vt, workspace( tmp_work,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -159,6 +159,7 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, 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,
@@ -188,45 +189,51 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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())) );
BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
equed == 'B' );
BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- 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::gesvx( fact, trans(), size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(af), stride_major(af), begin_value(ipiv), equed,
- begin_value(r), begin_value(c), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gesvx( fact, 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),
+ equed, bindings::begin_value(r), bindings::begin_value(c),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -243,11 +250,12 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, 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( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr,
berr, workspace( tmp_work, tmp_iwork ) );
}
@@ -266,6 +274,7 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr,
berr, minimal_workspace() );
@@ -311,6 +320,7 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, 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< VectorR >::type >::type,
@@ -336,45 +346,51 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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())) );
BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
equed == 'B' );
BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- 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::gesvx( fact, trans(), size_column_op(a, trans()),
- size_column(b), begin_value(a), stride_major(a),
- begin_value(af), stride_major(af), begin_value(ipiv), equed,
- begin_value(r), begin_value(c), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gesvx( fact, 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),
+ equed, bindings::begin_value(r), bindings::begin_value(c),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -391,11 +407,12 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, 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( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr,
berr, workspace( tmp_work, tmp_rwork ) );
}
@@ -414,6 +431,7 @@
VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b,
MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr,
berr, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -160,6 +160,7 @@
fortran_int_t& sdim, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, detail::workspace2< WORK, BWORK > 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<
@@ -184,39 +185,46 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVSR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixVSL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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< MatrixVSL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) );
+ BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsl) == 1 ||
+ bindings::stride_minor(vsl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsr) == 1 ||
+ bindings::stride_minor(vsr) == 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( jobvsl == 'N' || jobvsl == 'V' );
BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
- BOOST_ASSERT( size(alphai) >= size_column(a) );
- BOOST_ASSERT( size(alphar) >= size_column(a) );
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- 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_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(vsl) == 1 || stride_minor(vsl) == 1 );
- BOOST_ASSERT( size_minor(vsr) == 1 || stride_minor(vsr) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- 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::gges( jobvsl, jobvsr, sort, selctg, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), sdim, begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(vsl),
- stride_major(vsl), begin_value(vsr), stride_major(vsr),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(bool())) );
+ return detail::gges( jobvsl, jobvsr, sort, selctg,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim,
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -234,10 +242,11 @@
fortran_int_t& sdim, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, 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< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alphar,
alphai, beta, vsl, vsr, workspace( tmp_work, tmp_bwork ) );
}
@@ -257,15 +266,19 @@
fortran_int_t& sdim, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::gges( jobvsl, jobvsr, sort, selctg, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), sdim, begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(vsl),
- stride_major(vsl), begin_value(vsr), stride_major(vsr),
- &opt_size_work, -1, begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::gges( jobvsl, jobvsr, sort, selctg,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim,
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), &opt_size_work, -1,
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alphar,
@@ -316,6 +329,7 @@
fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta,
MatrixVSL& vsl, MatrixVSR& vsr, detail::workspace3< WORK, RWORK,
BWORK > 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<
@@ -336,40 +350,47 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVSR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsl) == 1 ||
+ bindings::stride_minor(vsl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsr) == 1 ||
+ bindings::stride_minor(vsr) == 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( jobvsl == 'N' || jobvsl == 'V' );
BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= size_column(a) );
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- 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_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(vsl) == 1 || stride_minor(vsl) == 1 );
- BOOST_ASSERT( size_minor(vsr) == 1 || stride_minor(vsr) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- 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::gges( jobvsl, jobvsr, sort, selctg, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), sdim, begin_value(alpha), begin_value(beta),
- begin_value(vsl), stride_major(vsl), begin_value(vsr),
- stride_major(vsr), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(bool())) );
+ return detail::gges( jobvsl, jobvsr, sort, selctg,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim, bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -385,12 +406,13 @@
const char sort, logical_t* selctg, MatrixA& a, MatrixB& b,
fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta,
MatrixVSL& vsl, MatrixVSR& vsr, 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) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alpha, beta,
vsl, vsr, workspace( tmp_work, tmp_rwork, tmp_bwork ) );
}
@@ -408,17 +430,21 @@
const char sort, logical_t* selctg, MatrixA& a, MatrixB& b,
fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta,
MatrixVSL& vsl, MatrixVSR& vsr, 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) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
- detail::gges( jobvsl, jobvsr, sort, selctg, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), sdim, begin_value(alpha), begin_value(beta),
- begin_value(vsl), stride_major(vsl), begin_value(vsr),
- stride_major(vsr), &opt_size_work, -1, begin_value(tmp_rwork),
- begin_value(tmp_bwork) );
+ bindings::size_column(a), sort ) );
+ detail::gges( jobvsl, jobvsr, sort, selctg,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim, bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alpha, beta,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -168,6 +168,7 @@
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv,
detail::workspace3< WORK, IWORK, BWORK > 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<
@@ -200,48 +201,55 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorRCONDV >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixVSL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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< MatrixVSL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a), sense ));
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a), sense ));
+ 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(vsl) == 1 ||
+ bindings::stride_minor(vsl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsr) == 1 ||
+ bindings::stride_minor(vsr) == 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( jobvsl == 'N' || jobvsl == 'V' );
BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(alphai) >= size_column(a) );
- BOOST_ASSERT( size(alphar) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a), sense ));
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a), sense ));
- 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(vsl) == 1 || stride_minor(vsl) == 1 );
- BOOST_ASSERT( size_minor(vsr) == 1 || stride_minor(vsr) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- 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::ggesx( jobvsl, jobvsr, sort, selctg, sense,
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), sdim, begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(vsl),
- stride_major(vsl), begin_value(vsr), stride_major(vsr),
- begin_value(rconde), begin_value(rcondv),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())),
- begin_value(work.select(bool())) );
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim,
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), bindings::begin_value(rconde),
+ bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -260,12 +268,13 @@
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a), sense ) );
+ bindings::size_column(a), sense ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a), sense ) );
+ min_size_iwork( bindings::size_column(a), sense ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim,
alphar, alphai, beta, vsl, vsr, rconde, rcondv,
workspace( tmp_work, tmp_iwork, tmp_bwork ) );
@@ -287,18 +296,23 @@
VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl,
MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a), sense ) );
+ min_size_iwork( bindings::size_column(a), sense ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), sdim, begin_value(alphar),
- begin_value(alphai), begin_value(beta), begin_value(vsl),
- stride_major(vsl), begin_value(vsr), stride_major(vsr),
- begin_value(rconde), begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_iwork), -1, begin_value(tmp_bwork) );
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim,
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), bindings::begin_value(rconde),
+ bindings::begin_value(rcondv), &opt_size_work, -1,
+ bindings::begin_value(tmp_iwork), -1,
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim,
@@ -371,6 +385,7 @@
VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr,
VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace4<
WORK, RWORK, IWORK, BWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorRCONDE >::type >::type,
typename remove_const< typename value<
@@ -395,49 +410,56 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVSR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVSR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( bindings::size_column(a), sense ));
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ bindings::size_column(a), sort ));
+ 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), sense ));
+ 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(vsl) == 1 ||
+ bindings::stride_minor(vsl) == 1 );
+ BOOST_ASSERT( bindings::size_minor(vsr) == 1 ||
+ bindings::stride_minor(vsr) == 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( jobvsl == 'N' || jobvsl == 'V' );
BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(a), sense ));
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork(
- size_column(a), sort ));
- 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), sense ));
- 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(vsl) == 1 || stride_minor(vsl) == 1 );
- BOOST_ASSERT( size_minor(vsr) == 1 || stride_minor(vsr) == 1 );
BOOST_ASSERT( sort == 'N' || sort == 'S' );
- 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::ggesx( jobvsl, jobvsr, sort, selctg, sense,
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), sdim, begin_value(alpha),
- begin_value(beta), begin_value(vsl), stride_major(vsl),
- begin_value(vsr), stride_major(vsr), begin_value(rconde),
- begin_value(rcondv), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(value_type())),
- begin_value(work.select(bool())) );
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim, bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), bindings::begin_value(rconde),
+ bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -456,14 +478,15 @@
VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a), sense ) );
+ bindings::size_column(a), sense ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a), sense ) );
+ min_size_iwork( bindings::size_column(a), sense ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, alpha,
beta, vsl, vsr, rconde, rcondv, workspace( tmp_work,
tmp_rwork, tmp_iwork, tmp_bwork ) );
@@ -485,21 +508,25 @@
VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
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) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a), sense ) );
+ min_size_iwork( bindings::size_column(a), sense ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork(
- size_column(a), sort ) );
+ bindings::size_column(a), sort ) );
detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
- size_column(a), begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), sdim, begin_value(alpha),
- begin_value(beta), begin_value(vsl), stride_major(vsl),
- begin_value(vsr), stride_major(vsr), begin_value(rconde),
- begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_rwork), begin_value(tmp_iwork), -1,
- begin_value(tmp_bwork) );
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), sdim, bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vsl),
+ bindings::stride_major(vsl), bindings::begin_value(vsr),
+ bindings::stride_major(vsr), bindings::begin_value(rconde),
+ bindings::begin_value(rcondv), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork), -1,
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, alpha,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -149,6 +149,7 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, 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<
@@ -173,34 +174,41 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(alphar) >= 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(alphai) >= size_column(a) );
- BOOST_ASSERT( size(alphar) >= 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_minor(b) == 1 || stride_minor(b) == 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(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::ggev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alphar), begin_value(alphai), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::ggev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -217,8 +225,9 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, 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( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr,
workspace( tmp_work ) );
}
@@ -237,12 +246,15 @@
MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl,
MatrixVR& vr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::ggev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alphar), begin_value(alphai), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), &opt_size_work, -1 );
+ detail::ggev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alphar), bindings::begin_value(alphai),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr,
@@ -280,6 +292,7 @@
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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<
@@ -300,36 +313,42 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= 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_minor(b) == 1 || stride_minor(b) == 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(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::ggev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alpha), begin_value(beta), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::ggev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -344,10 +363,11 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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( jobvl, jobvr, a, b, alpha, beta, vl, vr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -364,14 +384,17 @@
static std::ptrdiff_t invoke( const char jobvl, const char jobvr,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixVL& vl, MatrixVR& vr, 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::ggev( jobvl, jobvr, size_column(a), begin_value(a),
- stride_major(a), begin_value(b), stride_major(b),
- begin_value(alpha), begin_value(beta), begin_value(vl),
- stride_major(vl), begin_value(vr), stride_major(vr),
- &opt_size_work, -1, begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::ggev( jobvl, jobvr, bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr),
+ &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( jobvl, jobvr, a, b, alpha, beta, vl, vr,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -176,6 +176,7 @@
VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace3<
WORK, IWORK, BWORK > 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<
@@ -216,51 +217,59 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorRCONDV >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( sense, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ sense, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( balanc, jobvl, jobvr, sense,
+ 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
balanc == 'B' );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(alphai) >= size_column(a) );
- BOOST_ASSERT( size(alphar) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( sense, size_column(a) ));
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork( sense,
- size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( balanc,
- jobvl, jobvr, sense, size_column(a) ));
- 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(vl) == 1 || stride_minor(vl) == 1 );
- BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 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::ggevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alphar), begin_value(alphai),
- begin_value(beta), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), ilo, ihi,
- begin_value(lscale), begin_value(rscale), abnrm, bbnrm,
- begin_value(rconde), begin_value(rcondv),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(work.select(bool())) );
+ return detail::ggevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(alphar),
+ bindings::begin_value(alphai), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr), ilo,
+ ihi, bindings::begin_value(lscale),
+ bindings::begin_value(rscale), abnrm, bbnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -282,12 +291,13 @@
VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work( balanc,
- jobvl, jobvr, sense, size_column(a) ) );
+ jobvl, jobvr, sense, bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork( sense,
- size_column(a) ) );
+ bindings::size_column(a) ) );
return invoke( balanc, jobvl, jobvr, sense, a, b, alphar, alphai,
beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde,
rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) );
@@ -312,19 +322,24 @@
VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm,
VectorRCONDE& rconde, VectorRCONDV& rcondv,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork( sense,
- size_column(a) ) );
- detail::ggevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alphar), begin_value(alphai),
- begin_value(beta), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), ilo, ihi,
- begin_value(lscale), begin_value(rscale), abnrm, bbnrm,
- begin_value(rconde), begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_iwork), begin_value(tmp_bwork) );
+ bindings::size_column(a) ) );
+ detail::ggevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(alphar),
+ bindings::begin_value(alphai), bindings::begin_value(beta),
+ bindings::begin_value(vl), bindings::stride_major(vl),
+ bindings::begin_value(vr), bindings::stride_major(vr), ilo,
+ ihi, bindings::begin_value(lscale),
+ bindings::begin_value(rscale), abnrm, bbnrm,
+ bindings::begin_value(rconde), bindings::begin_value(rcondv),
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork),
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( balanc, jobvl, jobvr, sense, a, b, alphar, alphai,
@@ -399,6 +414,7 @@
VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm,
real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv,
detail::workspace4< WORK, RWORK, IWORK, BWORK > 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<
@@ -431,52 +447,60 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixVR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorRCONDV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) );
+ BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( sense, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(bool())) >= min_size_bwork(
+ sense, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( balanc, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( sense, 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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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(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( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
balanc == 'B' );
BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
sense == 'B' );
- BOOST_ASSERT( size(alpha) >= size_column(a) );
- BOOST_ASSERT( size(beta) >= size_column(a) );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( sense, size_column(a) ));
- BOOST_ASSERT( size(work.select(bool())) >= min_size_bwork( sense,
- size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- balanc, size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( sense,
- size_column(a) ));
- 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(vl) == 1 || stride_minor(vl) == 1 );
- BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 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::ggevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alpha), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), ilo, ihi, begin_value(lscale),
- begin_value(rscale), abnrm, bbnrm, begin_value(rconde),
- begin_value(rcondv), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(work.select(bool())) );
+ return detail::ggevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ abnrm, bbnrm, bindings::begin_value(rconde),
+ bindings::begin_value(rcondv),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(work.select(bool())) );
}
//
@@ -497,14 +521,15 @@
VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm,
real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work( sense,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- balanc, size_column(a) ) );
+ balanc, bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork( sense,
- size_column(a) ) );
+ bindings::size_column(a) ) );
return invoke( balanc, jobvl, jobvr, sense, a, b, alpha, beta, vl, vr,
ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv,
workspace( tmp_work, tmp_rwork, tmp_iwork, tmp_bwork ) );
@@ -528,22 +553,27 @@
VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm,
real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- balanc, size_column(a) ) );
+ balanc, bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( sense, size_column(a) ) );
+ min_size_iwork( sense, bindings::size_column(a) ) );
bindings::detail::array< bool > tmp_bwork( min_size_bwork( sense,
- size_column(a) ) );
- detail::ggevx( balanc, jobvl, jobvr, sense, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alpha), begin_value(beta),
- begin_value(vl), stride_major(vl), begin_value(vr),
- stride_major(vr), ilo, ihi, begin_value(lscale),
- begin_value(rscale), abnrm, bbnrm, begin_value(rconde),
- begin_value(rcondv), &opt_size_work, -1,
- begin_value(tmp_rwork), begin_value(tmp_iwork),
- begin_value(tmp_bwork) );
+ bindings::size_column(a) ) );
+ detail::ggevx( balanc, jobvl, jobvr, sense,
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(alpha),
+ bindings::begin_value(beta), bindings::begin_value(vl),
+ bindings::stride_major(vl), bindings::begin_value(vr),
+ bindings::stride_major(vr), ilo, ihi,
+ bindings::begin_value(lscale), bindings::begin_value(rscale),
+ abnrm, bbnrm, bindings::begin_value(rconde),
+ bindings::begin_value(rcondv), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork),
+ bindings::begin_value(tmp_bwork) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( balanc, jobvl, jobvr, sense, a, b, alpha, beta, vl, vr,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
typename VectorX, typename VectorY, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, 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<
@@ -156,29 +157,35 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size(d) >= size_row(a) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(a), size_row(a), size_column(b) ));
- BOOST_ASSERT( size(x) >= size_column(a) );
- BOOST_ASSERT( size(y) >= size_column(b) );
- BOOST_ASSERT( size_column(b) >= size_row(a)-size_column(a) );
- 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::ggglm( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(d), begin_value(x),
- begin_value(y), 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_column(a),
+ bindings::size_row(a), bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(y) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size_column(b) >=
+ bindings::size_row(a)-bindings::size_column(a) );
+ 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::ggglm( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(d),
+ bindings::begin_value(x), bindings::begin_value(y),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -192,8 +199,10 @@
typename VectorX, typename VectorY >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(a), size_row(a), size_column(b) ) );
+ bindings::size_column(a), bindings::size_row(a),
+ bindings::size_column(b) ) );
return invoke( a, b, d, x, y, workspace( tmp_work ) );
}
@@ -208,11 +217,14 @@
typename VectorX, typename VectorY >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::ggglm( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(d), begin_value(x),
- begin_value(y), &opt_size_work, -1 );
+ detail::ggglm( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(d),
+ bindings::begin_value(x), bindings::begin_value(y),
+ &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, d, x, y, workspace( tmp_work ) );
@@ -247,6 +259,7 @@
typename VectorX, typename VectorY, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, 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<
@@ -263,29 +276,35 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
- BOOST_ASSERT( size(d) >= size_row(a) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(a), size_row(a), size_column(b) ));
- BOOST_ASSERT( size(x) >= size_column(a) );
- BOOST_ASSERT( size(y) >= size_column(b) );
- BOOST_ASSERT( size_column(b) >= size_row(a)-size_column(a) );
- 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::ggglm( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(d), begin_value(x),
- begin_value(y), 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_column(a),
+ bindings::size_row(a), bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) );
+ BOOST_ASSERT( bindings::size(y) >= bindings::size_column(b) );
+ BOOST_ASSERT( bindings::size_column(b) >=
+ bindings::size_row(a)-bindings::size_column(a) );
+ 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::ggglm( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(d),
+ bindings::begin_value(x), bindings::begin_value(y),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -299,8 +318,10 @@
typename VectorX, typename VectorY >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(a), size_row(a), size_column(b) ) );
+ bindings::size_column(a), bindings::size_row(a),
+ bindings::size_column(b) ) );
return invoke( a, b, d, x, y, workspace( tmp_work ) );
}
@@ -315,11 +336,14 @@
typename VectorX, typename VectorY >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d,
VectorX& x, VectorY& y, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
- detail::ggglm( size_row(a), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(d), begin_value(x),
- begin_value(y), &opt_size_work, -1 );
+ detail::ggglm( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(d),
+ bindings::begin_value(x), bindings::begin_value(y),
+ &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, d, x, y, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
typename VectorD, typename VectorX, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, 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<
@@ -156,29 +157,34 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size(c) >= size_row(a) );
- BOOST_ASSERT( size(d) >= size_row(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_row(a), size_column(a), size_row(b) ));
- BOOST_ASSERT( size(x) >= size_column(a) );
- 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( 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::gglse( size_row(a), size_column(a), size_row(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(c), begin_value(d),
- begin_value(x), 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size(c) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_row(b) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), bindings::size_row(b) ));
+ BOOST_ASSERT( bindings::size(x) >= 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_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(b)) );
+ return detail::gglse( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::begin_value(d), bindings::begin_value(x),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -192,8 +198,10 @@
typename VectorD, typename VectorX >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_row(b) ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b) ) );
return invoke( a, b, c, d, x, workspace( tmp_work ) );
}
@@ -208,11 +216,14 @@
typename VectorD, typename VectorX >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
- detail::gglse( size_row(a), size_column(a), size_row(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(c), begin_value(d),
- begin_value(x), &opt_size_work, -1 );
+ detail::gglse( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::begin_value(d), bindings::begin_value(x),
+ &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, c, d, x, workspace( tmp_work ) );
@@ -247,6 +258,7 @@
typename VectorD, typename VectorX, typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, 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<
@@ -263,29 +275,34 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
- BOOST_ASSERT( size(c) >= size_row(a) );
- BOOST_ASSERT( size(d) >= size_row(b) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_row(a), size_column(a), size_row(b) ));
- BOOST_ASSERT( size(x) >= size_column(a) );
- 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( 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::gglse( size_row(a), size_column(a), size_row(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(c), begin_value(d),
- begin_value(x), 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< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
+ BOOST_ASSERT( bindings::size(c) >= bindings::size_row(a) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size_row(b) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( bindings::size_row(a),
+ bindings::size_column(a), bindings::size_row(b) ));
+ BOOST_ASSERT( bindings::size(x) >= 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_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(b)) );
+ return detail::gglse( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::begin_value(d), bindings::begin_value(x),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -299,8 +316,10 @@
typename VectorD, typename VectorX >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
- size_row(a), size_column(a), size_row(b) ) );
+ bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b) ) );
return invoke( a, b, c, d, x, workspace( tmp_work ) );
}
@@ -315,11 +334,14 @@
typename VectorD, typename VectorX >
static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c,
VectorD& d, VectorX& x, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
value_type opt_size_work;
- detail::gglse( size_row(a), size_column(a), size_row(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(c), begin_value(d),
- begin_value(x), &opt_size_work, -1 );
+ detail::gglse( bindings::size_row(a), bindings::size_column(a),
+ bindings::size_row(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(c),
+ bindings::begin_value(d), bindings::begin_value(x),
+ &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, b, c, d, x, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -157,6 +157,7 @@
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace2< WORK,
IWORK > 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<
@@ -181,40 +182,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< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::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< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::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(alpha) >= bindings::size_column(a) );
+ 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),
+ 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(alpha) >= size_column(a) );
- 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), 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::ggsvd( jobu, jobv, jobq, size_row(a), size_column(a),
- size_row(b), k, l, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alpha),
- begin_value(beta), begin_value(u), stride_major(u),
- begin_value(v), stride_major(v), begin_value(q),
- stride_major(q), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::ggsvd( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_column(a), bindings::size_row(b), k, l,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ 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(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -231,10 +241,12 @@
const char jobq, fortran_int_t& k, fortran_int_t& l,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q,
workspace( tmp_work, tmp_iwork ) );
}
@@ -253,6 +265,7 @@
const char jobq, fortran_int_t& k, fortran_int_t& l,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q,
minimal_workspace() );
}
@@ -298,6 +311,7 @@
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace3< WORK,
RWORK, IWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorALPHA >::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< VectorALPHA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorBETA >::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< VectorALPHA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::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(alpha) >= bindings::size_column(a) );
+ 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_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(alpha) >= size_column(a) );
- 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_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::ggsvd( jobu, jobv, jobq, size_row(a), size_column(a),
- size_row(b), k, l, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), begin_value(alpha),
- begin_value(beta), begin_value(u), stride_major(u),
- begin_value(v), stride_major(v), begin_value(q),
- stride_major(q), begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::ggsvd( jobu, jobv, jobq, bindings::size_row(a),
+ bindings::size_column(a), bindings::size_row(b), k, l,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(alpha), bindings::begin_value(beta),
+ 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(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -371,12 +394,14 @@
const char jobq, fortran_int_t& k, fortran_int_t& l,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
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) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- 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( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q,
workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -395,6 +420,7 @@
const char jobq, fortran_int_t& k, fortran_int_t& l,
MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta,
MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -117,6 +117,7 @@
typename MatrixB >
static std::ptrdiff_t invoke( const fortran_int_t n, VectorDL& dl,
VectorD& d, VectorDU& du, 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<
@@ -129,20 +130,23 @@
typename value< VectorDL >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDL >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDU >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU >::value) );
+ 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_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(dl) >= n-1 );
- BOOST_ASSERT( size(du) >= 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::gtsv( n, size_column(b), begin_value(dl),
- begin_value(d), begin_value(du), begin_value(b),
- stride_major(b) );
+ return detail::gtsv( n, bindings::size_column(b),
+ bindings::begin_value(dl), bindings::begin_value(d),
+ bindings::begin_value(du), bindings::begin_value(b),
+ bindings::stride_major(b) );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -165,6 +165,7 @@
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
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<
@@ -205,36 +206,43 @@
typename value< VectorDL >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDLF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDUF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDU2 >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< VectorDLF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDUF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU2 >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(dl) >= n-1 );
+ BOOST_ASSERT( bindings::size(du) >= 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( 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( fact == 'F' || fact == 'N' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(dl) >= n-1 );
- BOOST_ASSERT( size(du) >= n-1 );
- BOOST_ASSERT( 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::gtsvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::gtsvx( fact, 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), rcond,
+ 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 +261,7 @@
VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
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 ) );
@@ -276,6 +285,7 @@
VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x,
rcond, ferr, berr, minimal_workspace() );
}
@@ -323,6 +333,7 @@
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
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<
@@ -359,35 +370,43 @@
typename value< VectorDL >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDLF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDUF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDU2 >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< VectorDLF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDUF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU2 >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(dl) >= n-1 );
+ BOOST_ASSERT( bindings::size(du) >= 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( fact == 'F' || fact == 'N' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(dl) >= n-1 );
- BOOST_ASSERT( size(du) >= 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::gtsvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::gtsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -406,6 +425,7 @@
VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
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( fact, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x,
@@ -428,6 +448,7 @@
VectorDLF& dlf, VectorDF& df, VectorDUF& duf, VectorDU2& du2,
VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, n, dl, d, du, dlf, df, duf, du2, ipiv, b, x,
rcond, ferr, berr, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,29 +100,34 @@
typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, 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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::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(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo()) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- return detail::hbev( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hbev( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -135,11 +140,12 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, 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( jobz, ab, w, z, workspace( tmp_work, tmp_rwork ) );
}
@@ -153,6 +159,7 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, ab, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,35 +105,40 @@
typename WORK, typename RWORK, typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, detail::workspace3< WORK, RWORK, 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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, 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(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo()) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- return detail::hbevd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::hbevd( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), 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())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -146,13 +151,14 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, 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( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ab) ) );
+ min_size_iwork( jobz, bindings::size_column(ab) ) );
return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -167,14 +173,16 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hbevd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- &opt_size_rwork, -1, &opt_size_iwork, -1 );
+ detail::hbevd( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -117,6 +117,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK,
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,
@@ -126,36 +127,42 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(w) >= 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_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(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo()) );
+ BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= 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_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(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- BOOST_ASSERT( stride_major(q) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::hbevx( jobz, range, uplo(), size_column(ab),
- bandwidth(ab, uplo()), begin_value(ab), stride_major(ab),
- begin_value(q), stride_major(q), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::hbevx( jobz, range, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(q),
+ bindings::stride_major(q), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -172,13 +179,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z,
ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -197,6 +205,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z,
ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -104,6 +104,7 @@
typename MatrixZ, typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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,
@@ -113,29 +114,36 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, 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(z) == 1 ||
+ bindings::stride_minor(z) == 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( jobz == 'N' || jobz == 'V' );
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::hbgv( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hbgv( jobz, 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(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -149,11 +157,12 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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( jobz, ab, bb, w, z, workspace( tmp_work, tmp_rwork ) );
}
@@ -168,6 +177,7 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, ab, bb, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -112,6 +112,7 @@
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, detail::workspace3< WORK, RWORK,
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,
@@ -121,35 +122,42 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, 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(z) == 1 ||
+ bindings::stride_minor(z) == 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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(ab) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::hbgvd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::hbgvd( jobz, 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(w),
+ 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())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -163,13 +171,14 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ab) ) );
+ min_size_iwork( jobz, bindings::size_column(ab) ) );
return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -185,14 +194,17 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hbgvd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
+ detail::hbgvd( jobz, 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(w),
+ bindings::begin_value(z), bindings::stride_major(z),
&opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -119,6 +119,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
detail::workspace3< WORK, RWORK, 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,
@@ -132,38 +133,47 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, 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_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(q) == 1 ||
+ bindings::stride_minor(q) == 1 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( 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( size_minor(bb) == 1 || stride_minor(bb) == 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(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::hbgvx( jobz, range, uplo(), size_column(ab),
- bandwidth(ab, uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(q), stride_major(q), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::hbgvx( jobz, range, 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(q),
+ bindings::stride_major(q), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -181,13 +191,14 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ab) ) );
+ min_size_iwork( bindings::size_column(ab) ) );
return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w,
z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -207,6 +218,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w,
z, ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -99,23 +99,26 @@
typename RWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
detail::workspace2< WORK, RWORK > 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< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ 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( jobz == 'N' || jobz == 'V' );
- 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::heev( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::heev( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -128,11 +131,12 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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( jobz, a, w, workspace( tmp_work, tmp_rwork ) );
}
@@ -146,13 +150,15 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
- detail::heev( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::heev( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), &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( jobz, a, w, workspace( tmp_work, tmp_rwork ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,28 +102,31 @@
typename RWORK, typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
detail::workspace3< WORK, RWORK, IWORK > 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< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, 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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- 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::heevd( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::heevd( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -136,13 +139,14 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(a) ) );
+ min_size_iwork( jobz, bindings::size_column(a) ) );
return invoke( jobz, a, w, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -157,13 +161,15 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::heevd( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w), &opt_size_work, -1,
- &opt_size_rwork, -1, &opt_size_iwork, -1 );
+ detail::heevd( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), &opt_size_work, -1, &opt_size_rwork,
+ -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -117,39 +117,45 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace3< WORK, RWORK,
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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,
+ m) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ 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_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_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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,m) );
- BOOST_ASSERT( size(w) >= size_column(a) );
- 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_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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)) );
- return detail::heevr( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(isuppz), begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::heevr( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(isuppz),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -166,13 +172,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z,
isuppz, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -191,15 +198,17 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::heevr( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(isuppz), &opt_size_work, -1, &opt_size_rwork, -1,
- &opt_size_iwork, -1 );
+ detail::heevr( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(isuppz), &opt_size_work, -1,
+ &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -115,37 +115,41 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK,
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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ 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_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_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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= size_column(a) );
- 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_work(
- size_column(a) ));
- BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 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)) );
- return detail::heevx( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::heevx( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, 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())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -162,13 +166,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail,
workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -187,17 +192,20 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
- detail::heevx( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- &opt_size_work, -1, begin_value(tmp_rwork),
- begin_value(tmp_iwork), begin_value(ifail) );
+ min_size_iwork( bindings::size_column(a) ) );
+ detail::heevx( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ &opt_size_work, -1, bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork),
+ bindings::begin_value(ifail) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -103,32 +103,36 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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< 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< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ 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_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( jobz == 'N' || jobz == 'V' );
- 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_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::hegv( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hegv( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -142,11 +146,12 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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( itype, jobz, a, b, w, workspace( tmp_work,
tmp_rwork ) );
}
@@ -162,14 +167,16 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
- detail::hegv( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::hegv( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w), &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( itype, jobz, a, b, w, workspace( tmp_work,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,37 +105,41 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
detail::workspace3< WORK, RWORK, 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,
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< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, 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_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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(a) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- size_column(a) ));
- 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::hegvd( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::hegvd( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -149,13 +153,14 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(a) ) );
+ min_size_iwork( jobz, bindings::size_column(a) ) );
return invoke( itype, jobz, a, b, w, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -171,14 +176,16 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hegvd( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w), &opt_size_work, -1,
- &opt_size_rwork, -1, &opt_size_iwork, -1 );
+ detail::hegvd( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w), &opt_size_work, -1, &opt_size_rwork,
+ -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -118,6 +118,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK,
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,
@@ -127,37 +128,42 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ 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_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_minor(b) == 1 ||
+ bindings::stride_minor(b) == 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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= size_column(a) );
- 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_work(
- size_column(a) ));
- 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(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::hegvx( itype, jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), vl, vu, il, iu, abstol, m, begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::hegvx( itype, jobz, range, uplo(),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+ 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())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -175,13 +181,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
+ min_size_iwork( bindings::size_column(a) ) );
return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -201,18 +208,22 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
- detail::hegvx( itype, jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), vl, vu, il, iu, abstol, m, begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- begin_value(tmp_rwork), begin_value(tmp_iwork),
- begin_value(ifail) );
+ min_size_iwork( bindings::size_column(a) ) );
+ detail::hegvx( itype, jobz, range, uplo(),
+ bindings::size_column(a), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
+ bindings::begin_value(tmp_rwork),
+ bindings::begin_value(tmp_iwork),
+ bindings::begin_value(ifail) );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,28 +102,33 @@
typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work());
- 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::hesv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b),
- 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_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work());
+ 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::hesv( 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),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -136,6 +141,7 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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, b, workspace( tmp_work ) );
@@ -151,11 +157,14 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
- detail::hesv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b), &opt_size_work, -1 );
+ detail::hesv( 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),
+ &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, ipiv, b, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -113,6 +113,7 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -130,39 +131,45 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::hesvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hesvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -179,11 +186,12 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, a, af, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -202,16 +210,19 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
- detail::hesvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::hesvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ &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( fact, a, af, ipiv, b, x, rcond, ferr, berr,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -97,25 +97,28 @@
typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ 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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- 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_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpev( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hpev( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -128,11 +131,12 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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( jobz, ap, w, z, workspace( tmp_work, tmp_rwork ) );
}
@@ -146,6 +150,7 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( jobz, ap, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -102,31 +102,34 @@
typename WORK, typename RWORK, typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, detail::workspace3< WORK, RWORK, 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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpevd( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::hpevd( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), 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())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -139,13 +142,14 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ap) ) );
+ min_size_iwork( jobz, bindings::size_column(ap) ) );
return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -160,12 +164,14 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hpevd( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
+ detail::hpevd( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
&opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -112,32 +112,35 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK,
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,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ 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_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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( 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_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpevx( jobz, range, uplo(), size_column(ap),
- begin_value(ap), vl, vu, il, iu, abstol, m, begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::hpevx( jobz, range, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -154,13 +157,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z,
ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -179,6 +183,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z,
ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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< MatrixAP >::type >::type,
@@ -109,22 +110,24 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ 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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- 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_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpgv( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hpgv( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -139,11 +142,12 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_rwork ) );
}
@@ -160,6 +164,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -105,6 +105,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, detail::workspace3< WORK, RWORK, 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,
@@ -114,28 +115,30 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpgvd( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ 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())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -150,13 +153,14 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ap) ) );
+ min_size_iwork( jobz, bindings::size_column(ap) ) );
return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_rwork, tmp_iwork ) );
}
@@ -173,13 +177,15 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hpgvd( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
+ detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
&opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -115,6 +115,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK,
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,
@@ -124,29 +125,32 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::size(w) >= 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_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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= 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_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_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpgvx( itype, jobz, range, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::hpgvx( itype, jobz, range, uplo(),
+ bindings::size_column(ap), bindings::begin_value(ap),
+ bindings::begin_value(bp), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -164,13 +168,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(ap) ) );
+ min_size_iwork( bindings::size_column(ap) ) );
return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
w, z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
@@ -190,6 +195,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
w, z, ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -95,22 +95,25 @@
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixAP& ap, 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< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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::hpsv( 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< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ 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::hpsv( 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/driver/hpsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -107,6 +107,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -124,31 +125,35 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAFP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAFP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::hpsvx( fact, 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), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::hpsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -165,11 +170,12 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -188,6 +194,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -87,9 +87,10 @@
template< typename VectorX >
static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
const fortran_int_t incx ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
BOOST_ASSERT( n >= 0 );
- return detail::lacgv( n, begin_value(x), incx );
+ return detail::lacgv( n, bindings::begin_value(x), incx );
}
};
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -140,6 +140,7 @@
const fortran_int_t smlsiz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, 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<
@@ -148,27 +149,30 @@
typename value< VectorD >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
static_cast<std::ptrdiff_t>(
std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+
1)) /
std::log(static_cast<real_type>(2.)) ) + 1 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( n, nlvl ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n,
- smlsiz, nlvl, size_column(b) ));
- BOOST_ASSERT( size_column(b) >= 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::lalsd( uplo, smlsiz, n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b), rcond, rank,
- 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, smlsiz, nlvl, bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size_column(b) >= 1 );
+ 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 );
+ return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(b), bindings::stride_major(b), rcond,
+ rank, bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -183,13 +187,14 @@
const fortran_int_t smlsiz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
static_cast<std::ptrdiff_t>(
std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+
1)) /
std::log(static_cast<real_type>(2.)) ) + 1 );
bindings::detail::array< real_type > tmp_work( min_size_work( n,
- smlsiz, nlvl, size_column(b) ) );
+ smlsiz, nlvl, bindings::size_column(b) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( n, nlvl ) );
return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
@@ -208,6 +213,7 @@
const fortran_int_t smlsiz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
minimal_workspace() );
}
@@ -256,35 +262,39 @@
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, detail::workspace3< WORK, RWORK,
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<
VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
static_cast<std::ptrdiff_t>(
std::log(static_cast<real_type>(std::min<
std::ptrdiff_t >(traits::matrix_size2(b),n))/
static_cast<real_type>(smlsiz+1)) /
std::log(static_cast<real_type>(2.))) + 1 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
min_size_iwork( n, nlvl ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n,
- smlsiz, nlvl, size_column(b) ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n,
- size_column(b) ));
- BOOST_ASSERT( size_column(b) >= 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::lalsd( uplo, smlsiz, n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b), rcond, rank,
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( n, smlsiz, nlvl, bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work( n, bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size_column(b) >= 1 );
+ 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 );
+ return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(b), bindings::stride_major(b), rcond,
+ rank, bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -299,6 +309,7 @@
const fortran_int_t smlsiz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
static_cast<std::ptrdiff_t>(
std::log(static_cast<real_type>(std::min<
@@ -306,9 +317,9 @@
static_cast<real_type>(smlsiz+1)) /
std::log(static_cast<real_type>(2.))) + 1 );
bindings::detail::array< value_type > tmp_work( min_size_work( n,
- size_column(b) ) );
+ bindings::size_column(b) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n,
- smlsiz, nlvl, size_column(b) ) );
+ smlsiz, nlvl, bindings::size_column(b) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( n, nlvl ) );
return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
@@ -327,6 +338,7 @@
const fortran_int_t smlsiz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
fortran_int_t& rank, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp 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/driver/pbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -126,24 +126,29 @@
//
template< typename MatrixAB, typename MatrixB >
static std::ptrdiff_t invoke( MatrixAB& ab, MatrixB& b ) {
+ 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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::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::pbsv( 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< MatrixAB >::value) );
+ 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::pbsv( 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/driver/pbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -159,6 +159,7 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -184,41 +185,50 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAFB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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::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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::pbsvx( fact, uplo(), size_column(ab), bandwidth(ab,
- uplo()), size_column(b), begin_value(ab), stride_major(ab),
- begin_value(afb), stride_major(afb), equed, begin_value(s),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::pbsvx( fact, 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),
+ equed, bindings::begin_value(s), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), rcond, bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -235,11 +245,12 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ab, afb, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_iwork ) );
}
@@ -258,6 +269,7 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
@@ -302,6 +314,7 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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< VectorS >::type >::type,
@@ -323,41 +336,50 @@
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< MatrixAFB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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::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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::pbsvx( fact, uplo(), size_column(ab), bandwidth(ab,
- uplo()), size_column(b), begin_value(ab), stride_major(ab),
- begin_value(afb), stride_major(afb), equed, begin_value(s),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::pbsvx( fact, 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),
+ equed, bindings::begin_value(s), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), rcond, bindings::begin_value(ferr),
+ bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -374,11 +396,12 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ab, afb, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -397,6 +420,7 @@
MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -190,24 +190,28 @@
//
template< typename MatrixA, typename MatrixB >
static std::ptrdiff_t invoke( 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< MatrixA >::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::posv( 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< MatrixA >::value) );
+ 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::posv( 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/driver/posvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -158,6 +158,7 @@
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
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,
@@ -183,42 +184,48 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::posvx( fact, uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(af),
- stride_major(af), equed, begin_value(s), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::posvx( fact, 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), equed, bindings::begin_value(s),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -234,11 +241,12 @@
static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af,
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
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( fact, a, af, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_iwork ) );
}
@@ -256,6 +264,7 @@
static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af,
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
@@ -300,6 +309,7 @@
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
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< VectorS >::type >::type,
@@ -321,42 +331,48 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::posvx( fact, uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(af),
- stride_major(af), equed, begin_value(s), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::posvx( fact, 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), equed, bindings::begin_value(s),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -372,11 +388,12 @@
static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af,
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
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( fact, a, af, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -394,6 +411,7 @@
static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af,
char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -123,20 +123,23 @@
//
template< typename MatrixAP, typename MatrixB >
static std::ptrdiff_t invoke( 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< MatrixAP >::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::ppsv( uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(b), stride_major(b) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ 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::ppsv( 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/driver/ppsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -154,6 +154,7 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -179,35 +180,39 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorAFP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorAFP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::ppsvx( fact, uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), equed, begin_value(s),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::ppsvx( fact, uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), equed, bindings::begin_value(s),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -224,11 +229,12 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ap, afp, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_iwork ) );
}
@@ -247,6 +253,7 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
@@ -291,6 +298,7 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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< VectorS >::type >::type,
@@ -312,35 +320,39 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorAFP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::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< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorAFP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::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(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)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
- 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::ppsvx( fact, uplo(), size_column(ap), size_column(b),
- begin_value(ap), begin_value(afp), equed, begin_value(s),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::ppsvx( fact, uplo(), bindings::size_column(ap),
+ bindings::size_column(b), bindings::begin_value(ap),
+ bindings::begin_value(afp), equed, bindings::begin_value(s),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -357,11 +369,12 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ap, afp, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -380,6 +393,7 @@
VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr,
minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -122,6 +122,7 @@
template< typename VectorD, typename VectorE, typename MatrixB >
static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d,
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<
@@ -130,17 +131,20 @@
typename value< VectorD >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::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::ptsv( n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b) );
+ return detail::ptsv( n, bindings::size_column(b),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(b), bindings::stride_major(b) );
}
};
@@ -163,21 +167,25 @@
template< typename VectorD, typename VectorE, typename MatrixB >
static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d,
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< VectorD >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::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::ptsv( n, size_column(b), begin_value(d),
- begin_value(e), begin_value(b), stride_major(b) );
+ return detail::ptsv( 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/driver/ptsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -145,6 +145,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, 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,27 +174,34 @@
typename value< VectorD >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorEF >::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< VectorDF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorEF >::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(e) >= 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( fact == 'F' || fact == 'N' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- 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_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::ptsvx( fact, 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), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())) );
+ return detail::ptsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -210,6 +218,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, 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( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
workspace( tmp_work ) );
@@ -229,6 +238,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
minimal_workspace() );
}
@@ -265,6 +275,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, 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,29 +300,37 @@
typename value< VectorE >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorDF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorEF >::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< VectorDF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorEF >::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(e) >= 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( fact == 'F' || fact == 'N' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= 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::ptsvx( fact, 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), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::ptsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -328,6 +347,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, 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( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
@@ -348,6 +368,7 @@
const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
VectorBERR& berr, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -98,6 +98,7 @@
typename WORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, 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,
@@ -107,21 +108,25 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::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(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo()) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- return detail::sbev( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::sbev( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -134,9 +139,10 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, 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( jobz, ab, w, z, workspace( tmp_work ) );
}
@@ -150,6 +156,7 @@
template< typename MatrixAB, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, ab, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -104,6 +104,7 @@
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, const fortran_int_t liwork, 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,
@@ -113,25 +114,30 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, 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(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
+ uplo()) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- size_column(ab) ));
- BOOST_ASSERT( size_column(ab) >= 0 );
- BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- return detail::sbevd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())), liwork );
+ return detail::sbevd( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ liwork );
}
//
@@ -145,11 +151,12 @@
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, const fortran_int_t liwork,
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( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ab) ) );
+ min_size_iwork( jobz, bindings::size_column(ab) ) );
return invoke( jobz, ab, w, z, liwork, workspace( tmp_work,
tmp_iwork ) );
}
@@ -165,13 +172,15 @@
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
MatrixZ& z, const fortran_int_t liwork,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::sbevd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), begin_value(ab), stride_major(ab), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::sbevd( jobz, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -113,6 +113,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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,
@@ -126,33 +127,39 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(w) >= 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::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(ab) >= bindings::bandwidth(ab,
+ uplo()) );
+ BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1,
+ bindings::size_column(ab)) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= 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( size_minor(q) == 1 || stride_minor(q) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo()) );
- BOOST_ASSERT( stride_major(q) >= std::max< std::ptrdiff_t >(1,
- size_column(ab)) );
- return detail::sbevx( jobz, range, uplo(), size_column(ab),
- bandwidth(ab, uplo()), begin_value(ab), stride_major(ab),
- begin_value(q), stride_major(q), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::sbevx( jobz, range, uplo(), bindings::size_column(ab),
+ bindings::bandwidth(ab, uplo()), bindings::begin_value(ab),
+ bindings::stride_major(ab), bindings::begin_value(q),
+ bindings::stride_major(q), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -169,11 +176,12 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z,
ifail, workspace( tmp_work, tmp_iwork ) );
}
@@ -192,6 +200,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z,
ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
typename MatrixZ, typename WORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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,
@@ -113,26 +114,33 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, 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(z) == 1 ||
+ bindings::stride_minor(z) == 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( jobz == 'N' || jobz == 'V' );
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::sbgv( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::sbgv( jobz, 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(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -146,9 +154,10 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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( jobz, ab, bb, w, z, workspace( tmp_work ) );
}
@@ -163,6 +172,7 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, ab, bb, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -107,6 +107,7 @@
typename MatrixZ, typename WORK, typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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,
@@ -120,31 +121,38 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ab) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, 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(z) == 1 ||
+ bindings::stride_minor(z) == 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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ab) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- 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(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::sbgvd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::sbgvd( jobz, 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(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -158,11 +166,12 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, 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( jobz,
- size_column(ab) ) );
+ bindings::size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ab) ) );
+ min_size_iwork( jobz, bindings::size_column(ab) ) );
return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_iwork ) );
}
@@ -177,13 +186,16 @@
typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb,
VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::sbgvd( jobz, uplo(), size_column(ab), bandwidth(ab,
- uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(w), begin_value(z), stride_major(z),
+ detail::sbgvd( jobz, 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(w),
+ bindings::begin_value(z), bindings::stride_major(z),
&opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -115,6 +115,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
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,
@@ -132,35 +133,44 @@
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
- BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= 0 );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
+ BOOST_ASSERT( bindings::bandwidth(bb, 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::size_minor(bb) == 1 ||
+ bindings::stride_minor(bb) == 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(ab) >= bindings::bandwidth(ab,
+ uplo())+1 );
+ BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb,
+ uplo())+1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- 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( size_minor(bb) == 1 || stride_minor(bb) == 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(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
- return detail::sbgvx( jobz, range, uplo(), size_column(ab),
- bandwidth(ab, uplo()), bandwidth(bb, uplo()), begin_value(ab),
- stride_major(ab), begin_value(bb), stride_major(bb),
- begin_value(q), stride_major(q), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::sbgvx( jobz, range, 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(q),
+ bindings::stride_major(q), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -178,11 +188,12 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
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( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w,
z, ifail, workspace( tmp_work, tmp_iwork ) );
}
@@ -202,6 +213,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w,
z, ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -83,6 +83,7 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
detail::workspace2< WORK, SWORK > 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<
@@ -91,29 +92,35 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( size(ipiv) >= stride_major(work) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_swork(
- stride_major(work), size_column(b) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(work) >= 0 );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- return detail::sgesv( stride_major(work), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b), begin_value(x),
- stride_major(x), begin_value(work),
- begin_value(work.select(real_type())), iter );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::size(ipiv) >= bindings::stride_major(work) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_swork( bindings::stride_major(work),
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(work) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ return detail::sgesv( bindings::stride_major(work),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(ipiv),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(x), bindings::stride_major(x),
+ bindings::begin_value(work),
+ bindings::begin_value(work.select(real_type())), iter );
}
//
@@ -128,10 +135,11 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
bindings::detail::array< real_type > tmp_swork( min_size_swork(
- stride_major(work), size_column(b) ) );
+ bindings::stride_major(work), bindings::size_column(b) ) );
return invoke( a, ipiv, b, x, iter, workspace( tmp_work, tmp_swork ) );
}
@@ -147,6 +155,7 @@
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv,
const MatrixB& b, MatrixX& x, fortran_int_t& iter,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( a, ipiv, b, x, iter, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -96,6 +96,7 @@
typename WORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, detail::workspace1< WORK > 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,
@@ -105,17 +106,19 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ 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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spev( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::spev( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -128,9 +131,10 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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( jobz, ap, w, z, workspace( tmp_work ) );
}
@@ -144,6 +148,7 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( jobz, ap, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,6 +100,7 @@
typename WORK, typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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,
@@ -109,22 +110,24 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spevd( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::spevd( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -137,11 +140,12 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, 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( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ap) ) );
+ min_size_iwork( jobz, bindings::size_column(ap) ) );
return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) );
}
@@ -155,11 +159,13 @@
template< typename MatrixAP, typename VectorW, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::spevd( jobz, uplo(), size_column(ap), begin_value(ap),
- begin_value(w), begin_value(z), stride_major(z),
+ detail::spevd( jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
&opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -107,6 +107,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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,
@@ -116,24 +117,26 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ 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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- 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_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spevx( jobz, range, uplo(), size_column(ap),
- begin_value(ap), vl, vu, il, iu, abstol, m, begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::spevx( jobz, range, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -150,11 +153,12 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z,
ifail, workspace( tmp_work, tmp_iwork ) );
}
@@ -173,6 +177,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z,
ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -98,6 +98,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, detail::workspace1< WORK > 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,
@@ -111,19 +112,21 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ 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_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spgv( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::spgv( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -138,9 +141,10 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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( itype, jobz, ap, bp, w, z, workspace( tmp_work ) );
}
@@ -156,6 +160,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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,
@@ -114,24 +115,26 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, bindings::size_column(ap) ));
+ BOOST_ASSERT( bindings::size_column(ap) >= 0 );
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(ap) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- size_column(ap) ));
- BOOST_ASSERT( size_column(ap) >= 0 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spgvd( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::spgvd( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -146,11 +149,12 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, 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( jobz,
- size_column(ap) ) );
+ bindings::size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(ap) ) );
+ min_size_iwork( jobz, bindings::size_column(ap) ) );
return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_iwork ) );
}
@@ -167,12 +171,14 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::spgvd( itype, jobz, uplo(), size_column(ap),
- begin_value(ap), begin_value(bp), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
+ detail::spgvd( itype, jobz, uplo(), bindings::size_column(ap),
+ bindings::begin_value(ap), bindings::begin_value(bp),
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
&opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -111,6 +111,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
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,
@@ -124,25 +125,28 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixZ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixBP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ 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( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- 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 ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spgvx( itype, jobz, range, uplo(), n, begin_value(ap),
- begin_value(bp), vl, vu, il, iu, abstol, m, begin_value(w),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::spgvx( itype, jobz, range, uplo(), n,
+ bindings::begin_value(ap), bindings::begin_value(bp), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -161,6 +165,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
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( n ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -185,6 +190,7 @@
const fortran_int_t iu, const real_type abstol,
fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( itype, jobz, range, n, ap, bp, vl, vu, il, iu, abstol,
m, w, z, ifail, minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -84,6 +84,7 @@
typename WORK, typename SWORK >
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, detail::workspace2< WORK, SWORK > 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,
@@ -93,27 +94,32 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_swork(
- stride_major(work), size_column(b) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- $CALL_MIN_SIZE ));
- 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_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- BOOST_ASSERT( stride_major(work) >= 0 );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
- stride_major(work)) );
- return detail::sposv( uplo(), stride_major(work), size_column(b),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(work), begin_value(work.select(real_type())),
- iter );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_swork( bindings::stride_major(work),
+ bindings::size_column(b) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( $CALL_MIN_SIZE ));
+ 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_minor(x) == 1 ||
+ bindings::stride_minor(x) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ BOOST_ASSERT( bindings::stride_major(work) >= 0 );
+ BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ bindings::stride_major(work)) );
+ return detail::sposv( uplo(), bindings::stride_major(work),
+ bindings::size_column(b), bindings::begin_value(a),
+ bindings::stride_major(a), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(work),
+ bindings::begin_value(work.select(real_type())), iter );
}
//
@@ -126,11 +132,12 @@
template< typename MatrixA, typename MatrixB, typename MatrixX >
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, 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 ) );
bindings::detail::array< real_type > tmp_swork( min_size_swork(
- stride_major(work), size_column(b) ) );
+ bindings::stride_major(work), bindings::size_column(b) ) );
return invoke( a, b, x, iter, workspace( tmp_work, tmp_swork ) );
}
@@ -144,6 +151,7 @@
template< typename MatrixA, typename MatrixB, typename MatrixX >
static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x,
fortran_int_t& iter, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
return invoke( a, b, x, iter, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -125,22 +125,25 @@
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixAP& ap, 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< MatrixAP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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::spsv( 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< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) );
+ 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::spsv( 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/driver/spsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -150,6 +150,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -171,31 +172,35 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAFP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAFP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::spsvx( fact, 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), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::spsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -212,11 +217,12 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_iwork ) );
}
@@ -235,6 +241,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
minimal_workspace() );
@@ -279,6 +286,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -296,31 +304,35 @@
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAFP >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAFP >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::spsvx( fact, 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), rcond, begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::spsvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -337,11 +349,12 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -360,6 +373,7 @@
MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
minimal_workspace() );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -91,6 +91,7 @@
static std::ptrdiff_t invoke( const char jobz, 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<
@@ -99,17 +100,20 @@
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(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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
- 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::stev( jobz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())) );
+ return detail::stev( jobz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -122,6 +126,7 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, 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( jobz, n, d, e, z, workspace( tmp_work ) );
}
@@ -136,6 +141,7 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobz, n, d, e, z, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -98,6 +98,7 @@
static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixZ& z, 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<
@@ -106,23 +107,25 @@
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(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, n ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, n ));
+ BOOST_ASSERT( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(e) >= n-1 );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- n ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stevd( jobz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stevd( jobz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -135,6 +138,7 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, 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( jobz,
n ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -152,10 +156,12 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stevd( jobz, n, begin_value(d), begin_value(e),
- begin_value(z), stride_major(z), &opt_size_work, -1,
+ detail::stevd( jobz, n, bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(z),
+ bindings::stride_major(z), &opt_size_work, -1,
&opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -109,6 +109,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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<
@@ -121,29 +122,33 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= std::max< std::ptrdiff_t >(1,n-1) );
+ BOOST_ASSERT( bindings::size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,
+ m) );
+ 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( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= std::max< std::ptrdiff_t >(1,n-1) );
- BOOST_ASSERT( size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,m) );
- 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 ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stevr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::stevr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -161,6 +166,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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 ) );
@@ -183,12 +189,14 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::stevr( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(isuppz), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::stevr( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z), bindings::begin_value(isuppz),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -106,6 +106,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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,26 +119,30 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(e) >= std::max< std::ptrdiff_t >(1,n-1) );
+ 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( bindings::size_minor(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(e) >= std::max< std::ptrdiff_t >(1,n-1) );
- 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 ));
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::stevx( jobz, range, n, begin_value(d), begin_value(e),
- vl, vu, il, iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::stevx( jobz, range, n, bindings::begin_value(d),
+ bindings::begin_value(e), vl, vu, il, iu, abstol, m,
+ bindings::begin_value(w), bindings::begin_value(z),
+ bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -155,6 +160,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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 ) );
@@ -177,6 +183,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
ifail, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -97,24 +97,27 @@
template< typename MatrixA, typename VectorW, typename WORK >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ 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( jobz == 'N' || jobz == 'V' );
- 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::syev( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::syev( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -127,9 +130,10 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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) ) );
return invoke( jobz, a, w, workspace( tmp_work ) );
}
@@ -143,10 +147,12 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
- detail::syev( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w), &opt_size_work, -1 );
+ detail::syev( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobz, a, w, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -100,28 +100,31 @@
typename IWORK >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, 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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- 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::syevd( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::syevd( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -134,11 +137,12 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
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( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(a) ) );
+ min_size_iwork( jobz, bindings::size_column(a) ) );
return invoke( jobz, a, w, workspace( tmp_work, tmp_iwork ) );
}
@@ -152,12 +156,14 @@
template< typename MatrixA, typename VectorW >
static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::syevd( jobz, uplo(), size_column(a), begin_value(a),
- stride_major(a), begin_value(w), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::syevd( jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork,
+ -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -112,6 +112,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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,
@@ -121,30 +122,35 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorISUPPZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) );
+ BOOST_ASSERT( bindings::size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,
+ m) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ 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::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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(isuppz) >= 2*std::max< std::ptrdiff_t >(1,m) );
- BOOST_ASSERT( size(w) >= size_column(a) );
- 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( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::syevr( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(isuppz), begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::syevr( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(isuppz),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -161,11 +167,12 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, 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( jobz, range, a, vl, vu, il, iu, abstol, m, w, z,
isuppz, workspace( tmp_work, tmp_iwork ) );
}
@@ -184,13 +191,16 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::syevr( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(isuppz), &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::syevr( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(isuppz), &opt_size_work, -1,
+ &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -112,6 +112,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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,
@@ -121,29 +122,32 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
+ 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::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( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- BOOST_ASSERT( size(w) >= size_column(a) );
- 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( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_column(a)) );
- return detail::syevx( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::syevx( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -160,11 +164,12 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail,
workspace( tmp_work, tmp_iwork ) );
}
@@ -183,15 +188,17 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
- detail::syevx( jobz, range, uplo(), size_column(a),
- begin_value(a), stride_major(a), vl, vu, il, iu, abstol, m,
- begin_value(w), begin_value(z), stride_major(z),
- &opt_size_work, -1, begin_value(tmp_iwork),
- begin_value(ifail) );
+ min_size_iwork( bindings::size_column(a) ) );
+ detail::syevx( jobz, range, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork),
+ bindings::begin_value(ifail) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -101,6 +101,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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,
@@ -110,24 +111,27 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ 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_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( jobz == 'N' || jobz == 'V' );
- 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_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::sygv( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w),
- begin_value(work.select(real_type())),
- size(work.select(real_type())) );
+ return detail::sygv( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -141,9 +145,10 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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) ) );
return invoke( itype, jobz, a, b, w, workspace( tmp_work ) );
}
@@ -158,11 +163,13 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
- detail::sygv( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w), &opt_size_work, -1 );
+ detail::sygv( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w), &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( itype, jobz, a, b, w, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -103,6 +103,7 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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,
@@ -112,28 +113,31 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
+ min_size_iwork( jobz, bindings::size_column(a) ));
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( jobz, 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_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( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, size_column(a) ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- size_column(a) ));
- 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::sygvd( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- size(work.select(fortran_int_t())) );
+ return detail::sygvd( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::size(work.select(fortran_int_t())) );
}
//
@@ -147,11 +151,12 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
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( jobz,
- size_column(a) ) );
+ bindings::size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, size_column(a) ) );
+ min_size_iwork( jobz, bindings::size_column(a) ) );
return invoke( itype, jobz, a, b, w, workspace( tmp_work,
tmp_iwork ) );
}
@@ -167,13 +172,15 @@
static std::ptrdiff_t invoke( const fortran_int_t itype,
const char jobz, MatrixA& a, MatrixB& b, VectorW& w,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::sygvd( itype, jobz, uplo(), size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(w), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::sygvd( itype, jobz, uplo(), bindings::size_column(a),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b),
+ bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork,
+ -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -116,6 +116,7 @@
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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,
@@ -129,30 +130,38 @@
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< VectorW >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIFAIL >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
+ 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( 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(z) == 1 ||
+ bindings::stride_minor(z) == 1 );
+ BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ n) );
+ BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ n) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
- 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 ));
- BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
- BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sygvx( itype, jobz, range, uplo(), n, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b), vl, vu, il,
- iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())),
- begin_value(ifail) );
+ return detail::sygvx( itype, jobz, range, uplo(), n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())),
+ bindings::begin_value(ifail) );
}
//
@@ -170,6 +179,7 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, 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 ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -193,15 +203,18 @@
const fortran_int_t il, const fortran_int_t iu,
const real_type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( n ) );
- detail::sygvx( itype, jobz, range, uplo(), n, begin_value(a),
- stride_major(a), begin_value(b), stride_major(b), vl, vu, il,
- iu, abstol, m, begin_value(w), begin_value(z),
- stride_major(z), &opt_size_work, -1, begin_value(tmp_iwork),
- begin_value(ifail) );
+ detail::sygvx( itype, jobz, range, uplo(), n,
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(b), bindings::stride_major(b), vl, vu,
+ il, iu, abstol, m, bindings::begin_value(w),
+ bindings::begin_value(z), bindings::stride_major(z),
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork),
+ bindings::begin_value(ifail) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( itype, jobz, range, n, a, b, vl, vu, il, iu, abstol, m,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -143,28 +143,33 @@
typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work());
- 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::sysv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b),
- 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< VectorIPIV >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work());
+ 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::sysv( 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),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())) );
}
//
@@ -177,6 +182,7 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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() );
return invoke( a, ipiv, b, workspace( tmp_work ) );
@@ -192,11 +198,14 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
- detail::sysv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b), &opt_size_work, -1 );
+ detail::sysv( 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),
+ &opt_size_work, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, ipiv, b, workspace( tmp_work ) );
@@ -230,28 +239,33 @@
typename WORK >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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<
MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work());
- 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::sysv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b),
- 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_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
+ BOOST_ASSERT( bindings::size(work.select(value_type())) >=
+ min_size_work());
+ 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::sysv( 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),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())) );
}
//
@@ -264,6 +278,7 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
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, b, workspace( tmp_work ) );
@@ -279,11 +294,14 @@
template< typename MatrixA, typename VectorIPIV, typename MatrixB >
static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
- detail::sysv( uplo(), size_column(a), size_column(b),
- begin_value(a), stride_major(a), begin_value(ipiv),
- begin_value(b), stride_major(b), &opt_size_work, -1 );
+ detail::sysv( 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),
+ &opt_size_work, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( a, ipiv, b, workspace( tmp_work ) );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp 2010-01-14 07:12:01 EST (Thu, 14 Jan 2010)
@@ -160,6 +160,7 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -181,39 +182,45 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
VectorBERR >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::sysvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(real_type())),
- size(work.select(real_type())),
- begin_value(work.select(fortran_int_t())) );
+ return detail::sysvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(real_type())),
+ bindings::size(work.select(real_type())),
+ bindings::begin_value(work.select(fortran_int_t())) );
}
//
@@ -230,11 +237,12 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, a, af, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_iwork ) );
}
@@ -253,16 +261,19 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
real_type opt_size_work;
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(a) ) );
- detail::sysvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr), &opt_size_work, -1,
- begin_value(tmp_iwork) );
+ min_size_iwork( bindings::size_column(a) ) );
+ detail::sysvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ &opt_size_work, -1, bindings::begin_value(tmp_iwork) );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr,
@@ -308,6 +319,7 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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,
@@ -325,39 +337,45 @@
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< MatrixAF >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::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< MatrixAF >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::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(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)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- 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::sysvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr),
- begin_value(work.select(value_type())),
- size(work.select(value_type())),
- begin_value(work.select(real_type())) );
+ return detail::sysvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::begin_value(work.select(value_type())),
+ bindings::size(work.select(value_type())),
+ bindings::begin_value(work.select(real_type())) );
}
//
@@ -374,11 +392,12 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, 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( fact, a, af, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -397,16 +416,19 @@
MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::data_side< MatrixA >::type uplo;
value_type opt_size_work;
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(a) ) );
- detail::sysvx( fact, 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), rcond,
- begin_value(ferr), begin_value(berr), &opt_size_work, -1,
- begin_value(tmp_rwork) );
+ bindings::size_column(a) ) );
+ detail::sysvx( fact, 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), rcond,
+ bindings::begin_value(ferr), bindings::begin_value(berr),
+ &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( fact, a, af, ipiv, b, x, rcond, ferr, berr,
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk