Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r51663 - in sandbox/numeric_bindings: boost/numeric/bindings/blas/level1 boost/numeric/bindings/blas/level2 boost/numeric/bindings/blas/level3 boost/numeric/bindings/lapack/computational boost/numeric/bindings/lapack/driver libs/numeric/bindings/tools libs/numeric/bindings/tools/templates
From: rutger_at_[hidden]
Date: 2009-03-09 15:30:27


Author: rutger
Date: 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
New Revision: 51663
URL: http://svn.boost.org/trac/boost/changeset/51663

Log:
Switched from cassert to BOOST_ASSERT in lapack/blas

Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp | 1
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp | 34 ++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp | 50 +++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 60 ++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebak.hpp | 32 ++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebal.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp | 36 +++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp | 28 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 54 +++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp | 17 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp | 38 ++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 52 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp | 72 +++++++++++++++++++--------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp | 15 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 28 +++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp | 18 +++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp | 15 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp | 17 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp | 40 +++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 25 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp | 51 ++++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp | 21 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp | 43 +++++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp | 36 +++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp | 30 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp | 17 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 30 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 22 +++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 52 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp | 14 ++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 48 ++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp | 10 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp | 10 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 44 +++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 52 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 48 ++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp | 28 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 22 +++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp | 8 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp | 30 +++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 54 +++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp | 18 +++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp | 22 +++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp | 28 +++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp | 17 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 56 +++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 36 ++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 20 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 36 ++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 48 ++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp | 38 +++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 48 ++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 34 ++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp | 32 +++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp | 24 +++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 52 +++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp | 20 +++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp | 34 ++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp | 34 ++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp | 28 +++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp | 17 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 21 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp | 19 +++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 66 ++++++++++++++++++------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp | 45 ++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp | 53 +++++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp | 37 ++++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp | 65 ++++++++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp | 44 ++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp | 34 ++++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp | 42 +++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp | 38 ++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp | 32 +++++++----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp | 40 +++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp | 15 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp | 42 ++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 58 ++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp | 56 +++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp | 66 ++++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp | 44 ++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp | 66 ++++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 42 +++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 40 ++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 54 ++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp | 56 +++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 26 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp | 26 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp | 25 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp | 23 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 27 +++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 23 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp | 6 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp | 36 ++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp | 18 +++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 62 +++++++++++++++++-----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 58 ++++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 50 +++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 26 ++++++--------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 46 ++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp | 24 ++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 21 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 44 +++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp | 12 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp | 20 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp | 14 +++----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp | 23 ++++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp | 21 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp | 16 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 18 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp | 22 +++++------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp | 30 +++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 52 +++++++++++++---------------
   sandbox/numeric_bindings/libs/numeric/bindings/tools/blas_generator.py | 2
   sandbox/numeric_bindings/libs/numeric/bindings/tools/lapack_generator.py | 2
   sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py | 8 ++--
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/lapack.hpp | 4 --
   282 files changed, 2778 insertions(+), 3291 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/drot.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/srot.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -19,7 +19,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_BDSDC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_BDSDC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,16 +75,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( compq == 'N' || compq == 'P' || compq == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( compq == 'N' || compq == 'P' || compq == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( compq, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::bdsdc( uplo, compq, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(u),
                 traits::leading_dimension(u), traits::matrix_storage(vt),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_BDSQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_BDSQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -100,18 +100,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(vt) >= 0 );
- assert( traits::matrix_num_rows(u) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(u) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(vt) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(u) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(u) >= std::max(1,
                 traits::matrix_num_rows(u)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c) ));
-#endif
         detail::bdsqr( uplo, n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c),
                 traits::vector_storage(d), traits::vector_storage(e),
@@ -173,18 +171,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixVT >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(vt) >= 0 );
- assert( traits::matrix_num_rows(u) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(u) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(vt) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(u) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(u) >= std::max(1,
                 traits::matrix_num_rows(u)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c) ));
-#endif
         detail::bdsqr( uplo, n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBBRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBBRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -109,19 +109,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'Q' || vect == 'P' || vect == 'B' );
- assert( m >= 0 );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::vector_size(d) >= std::min(m,n) );
- assert( traits::vector_size(e) >= std::min(m,n)-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' ||
+ vect == 'B' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::vector_size(d) >= std::min(m,n) );
+ BOOST_ASSERT( traits::vector_size(e) >= std::min(m,n)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( m, n ));
-#endif
         detail::gbbrd( vect, m, n, traits::matrix_num_columns(c), kl, ku,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(d), traits::vector_storage(e),
@@ -187,21 +186,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'Q' || vect == 'P' || vect == 'B' );
- assert( m >= 0 );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::vector_size(d) >= std::min(m,n) );
- assert( traits::vector_size(e) >= std::min(m,n)-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' ||
+ vect == 'B' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::vector_size(d) >= std::min(m,n) );
+ BOOST_ASSERT( traits::vector_size(e) >= std::min(m,n)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( m, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( m, n ));
-#endif
         detail::gbbrd( vect, m, n, traits::matrix_num_columns(c), kl, ku,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -85,18 +85,16 @@
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= 2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::gbcon( norm, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),
                 anorm, rcond,
@@ -149,18 +147,16 @@
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= 2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::gbcon( norm, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),
                 anorm, rcond,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbequ.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBEQU_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBEQU_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -86,13 +86,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
-#endif
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
         detail::gbequ( m, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(r),
                 traits::vector_storage(c), rowcnd, colcnd, amax, info );
@@ -115,13 +113,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorR >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
-#endif
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
         detail::gbequ( m, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(r),
                 traits::vector_storage(c), rowcnd, colcnd, amax, info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -114,23 +114,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::leading_dimension(afb) >= 2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::gbrfs( trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(afb), traits::leading_dimension(afb),
@@ -207,23 +206,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::leading_dimension(afb) >= 2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::gbrfs( trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(afb), traits::leading_dimension(afb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBTRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBTRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,14 +66,12 @@
     static void compute( integer_t const m, integer_t const n,
             integer_t const kl, integer_t const ku, MatrixAB& ab,
             VectorIPIV& ipiv, integer_t& info ) {
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::leading_dimension(ab) >= 2 );
- assert( traits::vector_size(ipiv) >= std::min(m,n) );
-#endif
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= std::min(m,n) );
         detail::gbtrf( m, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),
                 info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,16 +75,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(ab) >= 2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::gbtrs( trans, n, kl, ku, traits::matrix_num_columns(b),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(ipiv), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEBAK_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEBAK_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,15 +82,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorSCALE >::value_type, typename traits::matrix_traits<
                 MatrixV >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( side == 'R' || side == 'L' );
- assert( traits::matrix_num_rows(v) >= 0 );
- assert( traits::vector_size(scale) >= traits::matrix_num_rows(v) );
- assert( traits::matrix_num_columns(v) >= 0 );
- assert( traits::leading_dimension(v) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( side == 'R' || side == 'L' );
+ BOOST_ASSERT( traits::matrix_num_rows(v) >= 0 );
+ BOOST_ASSERT( traits::vector_size(scale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::matrix_num_columns(v) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(v) >= std::max(1,
                 traits::matrix_num_rows(v)) );
-#endif
         detail::gebak( job, side, traits::matrix_num_rows(v), ilo, ihi,
                 traits::vector_storage(scale), traits::matrix_num_columns(v),
                 traits::matrix_storage(v), traits::leading_dimension(v),
@@ -110,15 +109,14 @@
     static void compute( char const job, char const side, integer_t const ilo,
             integer_t const ihi, VectorSCALE& scale, MatrixV& v,
             integer_t& info ) {
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( side == 'R' || side == 'L' );
- assert( traits::matrix_num_rows(v) >= 0 );
- assert( traits::vector_size(scale) >= traits::matrix_num_rows(v) );
- assert( traits::matrix_num_columns(v) >= 0 );
- assert( traits::leading_dimension(v) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( side == 'R' || side == 'L' );
+ BOOST_ASSERT( traits::matrix_num_rows(v) >= 0 );
+ BOOST_ASSERT( traits::vector_size(scale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::matrix_num_columns(v) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(v) >= std::max(1,
                 traits::matrix_num_rows(v)) );
-#endif
         detail::gebak( job, side, traits::matrix_num_rows(v), ilo, ihi,
                 traits::vector_storage(scale), traits::matrix_num_columns(v),
                 traits::matrix_storage(v), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEBAL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEBAL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,12 +75,10 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorSCALE >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::gebal( job, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), ilo,
                 ihi, traits::vector_storage(scale), info );
@@ -98,12 +96,10 @@
     template< typename MatrixA, typename VectorSCALE >
     static void compute( char const job, MatrixA& a, integer_t& ilo,
             integer_t& ihi, VectorSCALE& scale, integer_t& info ) {
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::gebal( job, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), ilo,
                 ihi, traits::vector_storage(scale), info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEBRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEBRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -96,23 +96,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUP >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(d) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(d) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(tauq) >=
+ BOOST_ASSERT( traits::vector_size(tauq) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(taup) >=
+ BOOST_ASSERT( traits::vector_size(taup) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) ));
-#endif
         detail::gebrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(d),
@@ -175,23 +174,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUP >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(d) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(d) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(tauq) >=
+ BOOST_ASSERT( traits::vector_size(tauq) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(taup) >=
+ BOOST_ASSERT( traits::vector_size(taup) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) ));
-#endif
         detail::gebrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(d),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GECON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GECON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -79,16 +79,14 @@
     static void compute( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gecon( norm, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 anorm, rcond,
@@ -136,16 +134,14 @@
     static void compute( char const norm, MatrixA& a, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gecon( norm, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 anorm, rcond,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geequ.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEEQU_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEEQU_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -79,12 +79,10 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
-#endif
         detail::geequ( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(r),
@@ -107,12 +105,10 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorR >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
-#endif
         detail::geequ( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(r),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEHRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEHRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -83,14 +83,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(a)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(tau),
@@ -140,14 +139,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(a)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELQF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GELQF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,17 +80,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a) ));
-#endif
         detail::gelqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
@@ -140,17 +138,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a) ));
-#endif
         detail::gelqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEQLF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEQLF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,17 +80,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::geqlf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
@@ -140,17 +138,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::geqlf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEQP3_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEQP3_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -83,17 +83,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::geqp3( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(jpvt),
@@ -145,19 +143,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::geqp3( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(jpvt),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,17 +80,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::geqrf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
@@ -140,17 +138,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::geqrf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GERFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GERFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -109,25 +109,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gerfs( trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(af),
@@ -201,25 +201,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gerfs( trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(af),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GERQF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GERQF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,17 +80,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::gerqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
@@ -140,17 +138,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >=
+ BOOST_ASSERT( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::gerqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GETRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GETRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,13 @@
     // templated specialization
     template< typename MatrixA, typename VectorIPIV >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(ipiv) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-#endif
         detail::getrf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GETRI_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GETRI_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,14 +75,13 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::getri( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv),
@@ -128,14 +127,13 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::getri( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GETRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GETRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,16 +71,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::getrs( trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbak.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGBAK_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGBAK_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -85,16 +85,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorLSCALE >::value_type, typename traits::matrix_traits<
                 MatrixV >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( side == 'R' || side == 'L' );
- assert( traits::matrix_num_rows(v) >= 0 );
- assert( traits::vector_size(lscale) >= traits::matrix_num_rows(v) );
- assert( traits::vector_size(rscale) >= traits::matrix_num_rows(v) );
- assert( traits::matrix_num_columns(v) >= 0 );
- assert( traits::leading_dimension(v) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( side == 'R' || side == 'L' );
+ BOOST_ASSERT( traits::matrix_num_rows(v) >= 0 );
+ BOOST_ASSERT( traits::vector_size(lscale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::vector_size(rscale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::matrix_num_columns(v) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(v) >= std::max(1,
                 traits::matrix_num_rows(v)) );
-#endif
         detail::ggbak( job, side, traits::matrix_num_rows(v), ilo, ihi,
                 traits::vector_storage(lscale),
                 traits::vector_storage(rscale), traits::matrix_num_columns(v),
@@ -118,16 +118,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorLSCALE >::value_type, typename traits::vector_traits<
                 VectorRSCALE >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( side == 'R' || side == 'L' );
- assert( traits::matrix_num_rows(v) >= 0 );
- assert( traits::vector_size(lscale) >= traits::matrix_num_rows(v) );
- assert( traits::vector_size(rscale) >= traits::matrix_num_rows(v) );
- assert( traits::matrix_num_columns(v) >= 0 );
- assert( traits::leading_dimension(v) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( side == 'R' || side == 'L' );
+ BOOST_ASSERT( traits::matrix_num_rows(v) >= 0 );
+ BOOST_ASSERT( traits::vector_size(lscale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::vector_size(rscale) >=
+ traits::matrix_num_rows(v) );
+ BOOST_ASSERT( traits::matrix_num_columns(v) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(v) >= std::max(1,
                 traits::matrix_num_rows(v)) );
-#endif
         detail::ggbak( job, side, traits::matrix_num_rows(v), ilo, ihi,
                 traits::vector_storage(lscale),
                 traits::vector_storage(rscale), traits::matrix_num_columns(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGBAL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGBAL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -94,14 +94,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorRSCALE >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggbal( job, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), ilo, ihi,
@@ -157,14 +155,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggbal( job, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), ilo, ihi,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGHRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGHRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -88,13 +88,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compq == 'N' || compq == 'I' || compq == 'V' );
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::gghrd( compq, compz, n, ilo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGQRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGQRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,23 +98,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taua) >=
+ BOOST_ASSERT( traits::vector_size(taua) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taub) >=
+ BOOST_ASSERT( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggqrf( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -178,23 +176,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taua) >=
+ BOOST_ASSERT( traits::vector_size(taua) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taub) >=
+ BOOST_ASSERT( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggqrf( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGRQF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGRQF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,23 +98,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(taua) >=
+ BOOST_ASSERT( traits::vector_size(taua) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taub) >=
+ BOOST_ASSERT( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggrqf( traits::matrix_num_rows(a), traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(taua),
@@ -178,23 +176,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAUB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(taua) >=
+ BOOST_ASSERT( traits::vector_size(taua) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(taub) >=
+ BOOST_ASSERT( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ggrqf( traits::matrix_num_rows(a), traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(taua),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGSVP_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGSVP_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -123,25 +123,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_tau( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
                 traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
-#endif
         detail::ggsvp( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -226,27 +224,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_tau( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
                 traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
-#endif
         detail::ggsvp( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GTRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GTRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -136,26 +136,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::vector_size(dlf) >= n-1 );
- assert( traits::vector_size(df) >= n );
- assert( traits::vector_size(duf) >= n-1 );
- assert( traits::vector_size(du2) >= n-2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(dlf) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(df) >= n );
+ BOOST_ASSERT( traits::vector_size(duf) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(du2) >= n-2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::gtrfs( trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::vector_storage(dlf),
@@ -252,26 +251,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::vector_size(dlf) >= n-1 );
- assert( traits::vector_size(df) >= n );
- assert( traits::vector_size(duf) >= n-1 );
- assert( traits::vector_size(du2) >= n-2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(dlf) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(df) >= n );
+ BOOST_ASSERT( traits::vector_size(duf) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(du2) >= n-2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::gtrfs( trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::vector_storage(dlf),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gttrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GTTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GTTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -88,16 +88,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::vector_size(du2) >= n-2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(du2) >= n-2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::gttrs( trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::vector_storage(du2),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBGST_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBGST_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,20 +72,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( vect == 'N' || vect == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= kb );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= kb );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hbgst( vect, traits::matrix_uplo_tag(a), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBTRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBTRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,17 +69,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'V' || vect == 'U' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
-#endif
         detail::hbtrd( vect, traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HECON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HECON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,14 @@
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::hecon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv), anorm, rcond,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEGST_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEGST_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -58,13 +58,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::hegst( itype, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HERFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HERFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,26 +82,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::herfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HETRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HETRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,17 +69,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(d) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(a)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( ));
-#endif
         detail::hetrd( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(d),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HETRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HETRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -57,15 +57,13 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( ));
-#endif
         detail::hetrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HETRI_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HETRI_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -57,15 +57,14 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::hetri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HETRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HETRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,16 +60,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::hetrs( uplo, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HGEQZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HGEQZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -121,16 +121,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'S' );
- assert( compq == 'N' || compq == 'I' || compq == 'V' );
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( traits::matrix_num_columns(h) >= 0 );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'S' );
+ BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(h) ));
-#endif
         detail::hgeqz( job, compq, compz, traits::matrix_num_columns(h), ilo,
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
                 traits::leading_dimension(h), traits::matrix_storage(t),
@@ -214,18 +214,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'S' );
- assert( compq == 'N' || compq == 'I' || compq == 'V' );
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( traits::matrix_num_columns(h) >= 0 );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'S' );
+ BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(h) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(h) ));
-#endif
         detail::hgeqz( job, compq, compz, traits::matrix_num_columns(h), ilo,
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
                 traits::leading_dimension(h), traits::matrix_storage(t),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -83,21 +83,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(afp) >= n*(n+1)/2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::matrix_storage(afp), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -58,14 +58,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(ap) >= n*(n+1)/2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(ap) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::hptrs( uplo, n, traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::vector_storage(ipiv),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HSEIN_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HSEIN_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -116,20 +116,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorIFAILL >::value_type, typename traits::vector_traits<
                 VectorIFAILR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( eigsrc == 'Q' || eigsrc == 'N' );
- assert( initv == 'N' || initv == 'U' );
- assert( traits::vector_size(select) >= traits::matrix_num_columns(h) );
- assert( traits::matrix_num_columns(h) >= 0 );
- assert( traits::leading_dimension(h) >= std::max(1,
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
+ BOOST_ASSERT( initv == 'N' || initv == 'U' );
+ BOOST_ASSERT( traits::vector_size(select) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(h) >= std::max(1,
                 traits::matrix_num_columns(h)) );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(wi) >= traits::matrix_num_columns(h) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(wi) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(h), ?2 ));
-#endif
         detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
                 traits::leading_dimension(h), traits::vector_storage(wr),
@@ -202,21 +203,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( eigsrc == 'Q' || eigsrc == 'N' );
- assert( initv == 'N' || initv == 'U' );
- assert( traits::vector_size(select) >= traits::matrix_num_columns(h) );
- assert( traits::matrix_num_columns(h) >= 0 );
- assert( traits::leading_dimension(h) >= std::max(1,
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
+ BOOST_ASSERT( initv == 'N' || initv == 'U' );
+ BOOST_ASSERT( traits::vector_size(select) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(h) >= std::max(1,
                 traits::matrix_num_columns(h)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(h) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(h) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(h) ));
-#endif
         detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
                 traits::leading_dimension(h), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HSEQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HSEQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,13 +98,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'S' );
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(h) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'S' );
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(h) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::hseqr( job, compz, traits::matrix_num_columns(h), ilo, ihi,
                 traits::matrix_storage(h), traits::leading_dimension(h),
                 traits::vector_storage(wr), traits::vector_storage(wi),
@@ -161,12 +160,10 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixH >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'S' );
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'S' );
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::hseqr( job, compz, traits::matrix_num_columns(h), ilo, ihi,
                 traits::matrix_storage(h), traits::leading_dimension(h),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LABRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LABRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -102,17 +102,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixY >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(e) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(tauq) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(taup) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(x) >= traits::matrix_num_rows(a) );
- assert( traits::leading_dimension(y) >=
+ BOOST_ASSERT( traits::vector_size(d) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(e) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(tauq) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(taup) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(x) >=
+ traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::leading_dimension(y) >=
                 traits::matrix_num_columns(a) );
-#endif
         detail::labrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -151,18 +154,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixY >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(e) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(tauq) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(taup) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(d) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(e) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(tauq) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(taup) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(y) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(y) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::labrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LACON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LACON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -70,13 +70,11 @@
     template< typename VectorX, typename V, typename ISGN >
     static void compute( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, detail::workspace2< V, ISGN > work ) {
-#ifndef NDEBUG
- assert( n >= 1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_v( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_isgn( n ));
-#endif
         detail::lacon( n, traits::vector_storage(work.select(real_type())),
                 traits::vector_storage(x),
                 traits::vector_storage(work.select(integer_t())), est, kase );
@@ -118,11 +116,9 @@
     template< typename VectorX, typename V >
     static void compute( integer_t const n, VectorX& x, real_type& est,
             integer_t& kase, detail::workspace1< V > work ) {
-#ifndef NDEBUG
- assert( n >= 1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_v( n ));
-#endif
         detail::lacon( n, traits::vector_storage(work.select(value_type())),
                 traits::vector_storage(x), est, kase );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAEBZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LAEBZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -87,15 +87,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorNVAL >::value_type, typename traits::matrix_traits<
                 MatrixNAB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n );
- assert( traits::vector_size(e2) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n );
+ BOOST_ASSERT( traits::vector_size(e2) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::leading_dimension(ab) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::leading_dimension(ab) ));
-#endif
         detail::laebz( ijob, nitmax, n, traits::leading_dimension(ab), minp,
                 nbmin, abstol, reltol, pivmin, traits::vector_storage(d),
                 traits::vector_storage(e), traits::vector_storage(e2),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LARZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LARZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,14 +82,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorV >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::larz( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), l, traits::vector_storage(v),
                 incv, tau, traits::matrix_storage(c),
@@ -139,14 +137,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorV >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::larz( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), l, traits::vector_storage(v),
                 incv, tau, traits::matrix_storage(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LATRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LATRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -84,13 +84,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixW >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::leading_dimension(a) >= (ERROR) );
- assert( traits::leading_dimension(w) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= (ERROR) );
+ BOOST_ASSERT( traits::leading_dimension(w) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::latrd( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), nb, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(e),
@@ -117,14 +115,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixW >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(h) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(h) == 'U' ||
                 traits::matrix_uplo_tag(h) == 'L' );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(w) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(w) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::latrd( traits::matrix_uplo_tag(h),
                 traits::matrix_num_columns(a), nb, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LATRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LATRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -87,15 +87,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorCNORM >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( normin == 'Y' || normin == 'N' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= ?MAX );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( normin == 'Y' || normin == 'N' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= ?MAX );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(a) );
         detail::latrs( uplo, trans, diag, normin,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(x),
@@ -118,15 +117,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorX >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( normin == 'Y' || normin == 'N' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= ?MAX );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( normin == 'Y' || normin == 'N' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= ?MAX );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(a) );
         detail::latrs( uplo, trans, diag, normin,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LATRZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LATRZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -77,16 +77,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a) ));
-#endif
         detail::latrz( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -127,16 +125,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a) ));
-#endif
         detail::latrz( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_OPGTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_OPGTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -62,18 +62,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(q) >= 0 );
- assert( traits::vector_size(ap) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(q) >= 0 );
+ BOOST_ASSERT( traits::vector_size(ap) >=
                 traits::matrix_num_columns(q)*(traits::matrix_num_columns(q)+
                 1)/2 );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(q)-1 );
- assert( traits::leading_dimension(q) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(q)-1 );
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(q)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(q) ));
-#endif
         detail::opgtr( uplo, traits::matrix_num_columns(q),
                 traits::vector_storage(ap), traits::vector_storage(tau),
                 traits::matrix_storage(q), traits::leading_dimension(q),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_OPMTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_OPMTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -65,18 +65,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::opmtr( side, uplo, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), traits::vector_storage(ap),
                 traits::vector_storage(tau), traits::matrix_storage(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGBR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGBR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,14 +60,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'Q' || vect == 'P' );
- assert( m >= 0 );
- assert( k >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( vect == 'Q' || vect == 'P' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( k >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( m, n ));
-#endif
         detail::orgbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGHR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGHR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,13 +60,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::vector_size(tau) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(tau) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::orghr( n, ilo, ihi, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGLQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGLQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= m );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= m );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( m ));
-#endif
         detail::orglq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGQL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGQL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= n );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= n );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::orgql( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= n );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= n );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::orgqr( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGRQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGRQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,15 +60,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= m );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= m );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( m ));
-#endif
         detail::orgrq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(real_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORGTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -59,15 +59,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::vector_size(tau) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(tau) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::orgtr( traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMBR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMBR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,20 +69,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'Q' || vect == 'P' );
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( k >= 0 );
- assert( traits::vector_size(tau) >= std::min(?NQ,k) );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( vect == 'Q' || vect == 'P' );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( k >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= std::min(?NQ,k) );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormbr( vect, side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMHR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMHR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,17 +71,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormhr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMLQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMLQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,19 +68,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormlq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMQL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMQL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,18 +68,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormql( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,18 +68,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormqr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMRQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMRQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,19 +68,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormrq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMRZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMRZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,18 +69,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::ormrz( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,19 +68,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::ormtr( side, traits::matrix_uplo_tag(a), trans,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,16 +80,14 @@
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::pbcon( uplo, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), anorm, rcond,
                 traits::vector_storage(work.select(real_type())),
@@ -137,16 +135,14 @@
             integer_t const kd, MatrixAB& ab, real_type const anorm,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::pbcon( uplo, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), anorm, rcond,
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBEQU_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBEQU_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,13 +75,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorS >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
         detail::pbequ( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(s), scond, amax, info );
@@ -99,13 +97,11 @@
     template< typename MatrixAB, typename VectorS >
     static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
             VectorS& s, real_type& scond, real_type& amax, integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
         detail::pbequ( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(s), scond, amax, info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -109,22 +109,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(afb) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::pbrfs( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(afb),
@@ -193,22 +192,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(afb) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::pbrfs( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(afb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBSTF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBSTF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -59,13 +59,11 @@
     template< typename MatrixAB >
     static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
             integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
         detail::pbstf( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBTRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBTRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -59,13 +59,11 @@
     template< typename MatrixAB >
     static void compute( integer_t const n, integer_t const kd, MatrixAB& ab,
             integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
         detail::pbtrf( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,14 +68,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::pbtrs( uplo, n, kd, traits::matrix_num_columns(b),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -78,17 +78,15 @@
     template< typename MatrixA, typename WORK, typename IWORK >
     static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, IWORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::pocon( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), anorm, rcond,
@@ -134,17 +132,15 @@
     template< typename MatrixA, typename WORK, typename RWORK >
     static void compute( MatrixA& a, real_type const anorm, real_type& rcond,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::pocon( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), anorm, rcond,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/poequ.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POEQU_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POEQU_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -73,11 +73,9 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorS >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::poequ( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(s), scond, amax, info );
@@ -95,11 +93,9 @@
     template< typename MatrixA, typename VectorS >
     static void compute( MatrixA& a, VectorS& s, real_type& scond,
             real_type& amax, integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::poequ( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(s), scond, amax, info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PORFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PORFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -108,25 +108,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::porfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -196,25 +195,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::porfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POTRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POTRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -58,13 +58,11 @@
     // templated specialization
     template< typename MatrixA >
     static void compute( MatrixA& a, integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::potrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potri.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POTRI_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POTRI_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -58,13 +58,11 @@
     // templated specialization
     template< typename MatrixA >
     static void compute( MatrixA& a, integer_t& info ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::potri( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/potrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -67,16 +67,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::potrs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PPRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -106,20 +106,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(afp) >= n*(n+1)/2 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::pprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::vector_storage(afp), traits::matrix_storage(b),
@@ -186,20 +185,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(afp) >= n*(n+1)/2 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::pprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::vector_storage(afp), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PPTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,13 +68,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::pptrs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(b), traits::vector_storage(ap),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PTEQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PTEQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,14 +82,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'V' || compz == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::pteqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),
@@ -132,14 +130,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'V' || compz == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::pteqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PTRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PTRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -113,19 +113,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(df) >= n );
- assert( traits::vector_size(ef) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(df) >= n );
+ BOOST_ASSERT( traits::vector_size(ef) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::ptrfs( n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::vector_storage(df), traits::vector_storage(ef),
@@ -199,22 +198,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorE >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(df) >= n );
- assert( traits::vector_size(ef) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(df) >= n );
+ BOOST_ASSERT( traits::vector_size(ef) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::ptrfs( uplo, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::vector_storage(df), traits::vector_storage(ef),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PTTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PTTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -76,13 +76,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::pttrs( n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -104,13 +102,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorE >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::pttrs( uplo, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBGST_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBGST_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,18 +68,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( vect == 'N' || vect == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= kb );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= kb );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::sbgst( vect, traits::matrix_uplo_tag(a), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBTRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBTRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -70,17 +70,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'N' || vect == 'V' || vect == 'U' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::sbtrd( vect, traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -109,21 +109,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(afp) >= n*(n+1)/2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::sprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::matrix_storage(afp), traits::vector_storage(ipiv),
@@ -194,21 +193,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(afp) >= n*(n+1)/2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::sprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::matrix_storage(afp), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,14 +68,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(ap) >= n*(n+1)/2 );
- assert( traits::vector_size(ipiv) >= n );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(ap) >= n*(n+1)/2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >= n );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::sptrs( uplo, n, traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::vector_storage(ipiv),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEBZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEBZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -78,19 +78,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorIBLOCK >::value_type, typename traits::vector_traits<
                 VectorISPLIT >::value_type >::value) );
-#ifndef NDEBUG
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( order == 'B' || order == 'E' );
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(isplit) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( order == 'B' || order == 'E' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(isplit) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::stebz( range, order, n, vl, vu, il, iu, abstol,
                 traits::vector_storage(d), traits::vector_storage(e), m,
                 nsplit, traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEDC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEDC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -93,15 +93,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( compz, n ));
-#endif
         detail::stedc( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),
@@ -163,17 +161,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'I' || compz == 'V' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( compz, n ));
-#endif
         detail::stedc( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEGR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEGR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -106,18 +106,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::stegr( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,
                 traits::vector_storage(w), traits::matrix_storage(z),
@@ -197,18 +195,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorW >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::stegr( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEIN_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEIN_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -100,18 +100,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorIBLOCK >::value_type, typename traits::vector_traits<
                 VectorIFAIL >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(isplit) >= n );
- assert( traits::leading_dimension(z) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(isplit) >= n );
+ BOOST_ASSERT( traits::leading_dimension(z) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::stein( n, traits::vector_storage(d),
                 traits::vector_storage(e), m, traits::vector_storage(w),
                 traits::vector_storage(iblock),
@@ -184,18 +182,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorIBLOCK >::value_type, typename traits::vector_traits<
                 VectorIFAIL >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(isplit) >= n );
- assert( traits::leading_dimension(z) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(isplit) >= n );
+ BOOST_ASSERT( traits::leading_dimension(z) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::stein( n, traits::vector_storage(d),
                 traits::vector_storage(e), m, traits::vector_storage(w),
                 traits::vector_storage(iblock),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,13 +82,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'V' || compz == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::steqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),
@@ -132,13 +130,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
-#ifndef NDEBUG
- assert( compz == 'N' || compz == 'V' || compz == 'I' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::steqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
                 traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sterf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STERF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STERF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -54,10 +54,8 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorE >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
         detail::sterf( n, traits::vector_storage(d),
                 traits::vector_storage(e), info );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,17 +80,16 @@
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace2< WORK, IWORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::sycon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv), anorm, rcond,
@@ -140,15 +139,14 @@
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             real_type const anorm, real_type& rcond, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::sycon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv), anorm, rcond,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYGST_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYGST_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -56,13 +56,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::sygst( itype, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -108,26 +108,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::syrfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -200,26 +200,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::syrfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYTRD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYTRD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,17 +66,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(d) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(a)-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::sytrd( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(d),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYTRF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYTRF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,15 +75,13 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::sytrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),
@@ -130,15 +128,13 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( MatrixA& a, VectorIPIV& ipiv, integer_t& info,
             detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::sytrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYTRI_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYTRI_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -74,15 +74,14 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::sytri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv),
@@ -121,15 +120,14 @@
     template< typename MatrixA, typename VectorIPIV, typename WORK >
     static void compute( char const uplo, MatrixA& a, VectorIPIV& ipiv,
             integer_t& info, detail::workspace1< WORK > work ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::sytri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SYTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,16 +71,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::sytrs( uplo, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TBCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TBCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,18 +82,16 @@
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             IWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::tbcon( norm, uplo, diag, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), rcond,
                 traits::vector_storage(work.select(real_type())),
@@ -142,18 +140,16 @@
             integer_t const n, integer_t const kd, MatrixAB& ab,
             real_type& rcond, integer_t& info, detail::workspace2< WORK,
             RWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::tbcon( norm, uplo, diag, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), rcond,
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TBRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TBRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -106,22 +106,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::tbrfs( uplo, trans, diag, n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(b),
@@ -189,22 +188,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::tbrfs( uplo, trans, diag, n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TBTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TBTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -77,16 +77,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::tbtrs( uplo, trans, diag, n, kd,
                 traits::matrix_num_columns(b), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGEVC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGEVC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -102,16 +102,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixS >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( howmny == 'A' || howmny == 'B' || howmny == 'S' );
- assert( n >= 0 );
- assert( traits::leading_dimension(s) >= std::max(1,n) );
- assert( traits::leading_dimension(p) >= std::max(1,n) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(s) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(p) >= std::max(1,n) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::tgevc( side, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(s), traits::leading_dimension(s),
                 traits::matrix_storage(p), traits::leading_dimension(p),
@@ -172,18 +170,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixS >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( howmny == 'A' || howmny == 'B' || howmny == 'S' );
- assert( n >= 0 );
- assert( traits::leading_dimension(s) >= std::max(1,n) );
- assert( traits::leading_dimension(p) >= std::max(1,n) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(s) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(p) >= std::max(1,n) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::tgevc( side, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(s), traits::leading_dimension(s),
                 traits::matrix_storage(p), traits::leading_dimension(p),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGEXC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGEXC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,13 +98,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::tgexc( wantq, wantz, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(q),
@@ -138,11 +136,9 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::tgexc( wantq, wantz, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(q),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGSEN_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGSEN_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -137,18 +137,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorDIF >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::vector_size(select) >= n );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(alphar) >= n );
- assert( traits::vector_size(alphai) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(select) >= n );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(alphar) >= n );
+ BOOST_ASSERT( traits::vector_size(alphai) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::tgsen( ijob, wantq, wantz, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -251,17 +249,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::vector_size(select) >= n );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(alpha) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(select) >= n );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(alpha) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::tgsen( ijob, wantq, wantz, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGSJA_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGSJA_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -128,21 +128,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'I' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'I' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'I' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'I' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(b) ));
-#endif
         detail::tgsja( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b), k,
                 l, traits::matrix_storage(a), traits::leading_dimension(a),
@@ -221,21 +220,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'I' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'I' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'I' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'I' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(b) ));
-#endif
         detail::tgsja( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b), k,
                 l, traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGSNA_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGSNA_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -115,18 +115,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorDIF >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'V' || job == 'B' );
- assert( howmny == 'A' || howmny == 'S' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::tgsna( job, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -217,18 +215,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'V' || job == 'B' );
- assert( howmny == 'A' || howmny == 'S' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::tgsna( job, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TGSYL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TGSYL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -123,13 +123,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixF >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( m, n ));
-#endif
         detail::tgsyl( trans, ijob, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(c),
@@ -219,13 +217,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixF >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'C' );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( m, n ));
-#endif
         detail::tgsyl( trans, ijob, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TPRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TPRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -102,20 +102,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::tprfs( uplo, trans, diag, n, traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(x),
@@ -182,20 +181,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::tprfs( uplo, trans, diag, n, traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TPTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TPTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,14 +68,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::tptrs( uplo, trans, diag, n, traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::matrix_storage(b),
                 traits::leading_dimension(b), info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRCON_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRCON_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -79,18 +79,16 @@
     static void compute( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info, detail::workspace2<
             WORK, IWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::trcon( norm, uplo, diag, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 rcond, traits::vector_storage(work.select(real_type())),
@@ -139,18 +137,16 @@
     static void compute( char const norm, char const uplo, char const diag,
             MatrixA& a, real_type& rcond, integer_t& info, detail::workspace2<
             WORK, RWORK > work ) {
-#ifndef NDEBUG
- assert( norm == '1' || norm == 'O' || norm == 'I' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::trcon( norm, uplo, diag, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 rcond, traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -95,16 +95,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( howmny == 'A' || howmny == 'B' || howmny == 'S' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(t) ));
-#endif
         detail::trevc( side, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
                 traits::leading_dimension(t), traits::matrix_storage(vl),
@@ -162,18 +160,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'R' || side == 'L' || side == 'B' );
- assert( howmny == 'A' || howmny == 'B' || howmny == 'S' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(t) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(t) ));
-#endif
         detail::trevc( side, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
                 traits::leading_dimension(t), traits::matrix_storage(vl),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -81,16 +81,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compq == 'V' || compq == 'N' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( compq == 'V' || compq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( traits::leading_dimension(q) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(t) ));
-#endif
         detail::trexc( compq, traits::matrix_num_columns(t),
                 traits::matrix_storage(t), traits::leading_dimension(t),
                 traits::matrix_storage(q), traits::leading_dimension(q), ifst,
@@ -113,14 +111,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( compq == 'V' || compq == 'N' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( compq == 'V' || compq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( traits::leading_dimension(q) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(t)) );
-#endif
         detail::trexc( compq, traits::matrix_num_columns(t),
                 traits::matrix_storage(t), traits::leading_dimension(t),
                 traits::matrix_storage(q), traits::leading_dimension(q), ifst,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRRFS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRRFS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -106,24 +106,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::trrfs( uplo, trans, diag, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -191,24 +190,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::trrfs( uplo, trans, diag, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRSEN_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRSEN_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -73,17 +73,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::vector_traits<
                 VectorW >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'N' || job == 'E' || job == 'V' || job == 'B' );
- assert( compq == 'V' || compq == 'N' );
- assert( traits::vector_size(select) >= traits::matrix_num_columns(t) );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( job == 'N' || job == 'E' || job == 'V' || job == 'B' );
+ BOOST_ASSERT( compq == 'V' || compq == 'N' );
+ BOOST_ASSERT( traits::vector_size(select) >=
+ traits::matrix_num_columns(t) );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(t) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(t) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::trsen( job, compq, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
                 traits::leading_dimension(t), traits::matrix_storage(q),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRSNA_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRSNA_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -107,18 +107,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::vector_traits<
                 VectorSEP >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'V' || job == 'B' );
- assert( howmny == 'A' || howmny == 'S' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
-#endif
         detail::trsna( job, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
                 traits::leading_dimension(t), traits::matrix_storage(vl),
@@ -188,18 +186,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixT >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( job == 'E' || job == 'V' || job == 'B' );
- assert( howmny == 'A' || howmny == 'S' );
- assert( traits::matrix_num_columns(t) >= 0 );
- assert( traits::leading_dimension(t) >= std::max(1,
+ BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' );
+ BOOST_ASSERT( howmny == 'A' || howmny == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(t) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
- assert( mm >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( mm >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( $CALL_MIN_SIZE ));
-#endif
         detail::trsna( job, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
                 traits::leading_dimension(t), traits::matrix_storage(vl),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsyl.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRSYL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRSYL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -90,15 +90,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( trana == 'N' || trana == 'T' || trana == 'C' );
- assert( tranb == 'N' || tranb == 'T' || tranb == 'C' );
- assert( m >= 0 );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(c) >= std::max(1,m) );
-#endif
+ BOOST_ASSERT( trana == 'N' || trana == 'T' || trana == 'C' );
+ BOOST_ASSERT( tranb == 'N' || tranb == 'T' || tranb == 'C' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,m) );
         detail::trsyl( trana, tranb, isgn, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(c),
@@ -125,15 +123,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( trana == 'N' || trana == 'C' );
- assert( tranb == 'N' || tranb == 'C' );
- assert( m >= 0 );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(c) >= std::max(1,m) );
-#endif
+ BOOST_ASSERT( trana == 'N' || trana == 'C' );
+ BOOST_ASSERT( tranb == 'N' || tranb == 'C' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,m) );
         detail::trsyl( trana, tranb, isgn, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
                 traits::leading_dimension(b), traits::matrix_storage(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtri.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRTRI_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRTRI_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -59,13 +59,11 @@
     template< typename MatrixA >
     static void compute( char const uplo, char const diag, MatrixA& a,
             integer_t& info ) {
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::trtri( uplo, diag, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 info );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TRTRS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TRTRS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -76,17 +76,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( diag == 'N' || diag == 'U' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( diag == 'N' || diag == 'U' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::trtrs( uplo, trans, diag, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TZRZF_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_TZRZF_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,15 +80,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= traits::matrix_num_rows(a) );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >=
+ traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::tzrzf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
@@ -138,15 +137,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= traits::matrix_num_rows(a) );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >=
+ traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::tzrzf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGBR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGBR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,14 +66,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'Q' || vect == 'P' );
- assert( m >= 0 );
- assert( k >= 0 );
- assert( traits::leading_dimension(a) >= m );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( vect == 'Q' || vect == 'P' );
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( k >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= m );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( m, n ));
-#endif
         detail::ungbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGHR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGHR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,13 +66,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::vector_size(tau) >= n-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(tau) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::unghr( n, ilo, ihi, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGLQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGLQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,15 +66,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= m );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= m );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( m ));
-#endif
         detail::unglq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGQL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGQL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,15 +66,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= n );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= n );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
-#endif
         detail::ungql( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,15 +66,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= n );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= n );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
-#endif
         detail::ungqr( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGRQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGRQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,15 +66,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( m >= 0 );
- assert( n >= m );
- assert( k >= k );
- assert( traits::leading_dimension(a) >= std::max(1,m) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( m >= 0 );
+ BOOST_ASSERT( n >= m );
+ BOOST_ASSERT( k >= k );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( m ));
-#endif
         detail::ungrq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),
                 traits::vector_storage(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNGTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNGTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -63,15 +63,13 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorTAU >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= n );
- assert( traits::vector_size(tau) >= n-1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= n );
+ BOOST_ASSERT( traits::vector_size(tau) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, m, n ));
-#endif
         detail::ungtr( traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMBR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMBR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -74,20 +74,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( vect == 'Q' || vect == 'P' );
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( k >= 0 );
- assert( traits::vector_size(tau) >= std::min(?NQ,k) );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( vect == 'Q' || vect == 'P' );
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( k >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= std::min(?NQ,k) );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmbr( vect, side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMHR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMHR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,17 +75,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmhr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMLQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMLQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,19 +72,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmlq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMQL_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMQL_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,18 +72,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmql( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMQR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMQR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,18 +72,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmqr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMRQ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMRQ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,19 +72,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmrq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMRZ_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMRZ_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,18 +72,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,k) );
- assert( traits::vector_size(tau) >= k );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,k) );
+ BOOST_ASSERT( traits::vector_size(tau) >= k );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::unmrz( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UNMTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UNMTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,19 +72,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c) ));
-#endif
         detail::unmtr( side, traits::matrix_uplo_tag(a), trans,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UPGTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UPGTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,18 +68,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( traits::matrix_num_columns(q) >= 0 );
- assert( traits::vector_size(ap) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( traits::matrix_num_columns(q) >= 0 );
+ BOOST_ASSERT( traits::vector_size(ap) >=
                 traits::matrix_num_columns(q)*(traits::matrix_num_columns(q)+
                 1)/2 );
- assert( traits::vector_size(tau) >= traits::matrix_num_columns(q)-1 );
- assert( traits::leading_dimension(q) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(tau) >=
+ traits::matrix_num_columns(q)-1 );
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(q)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(q) ));
-#endif
         detail::upgtr( uplo, traits::matrix_num_columns(q),
                 traits::vector_storage(ap), traits::vector_storage(tau),
                 traits::matrix_storage(q), traits::leading_dimension(q),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_UPMTR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_UPMTR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,17 +69,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorAP >::value_type, typename traits::matrix_traits<
                 MatrixC >::value_type >::value) );
-#ifndef NDEBUG
- assert( side == 'L' || side == 'R' );
- assert( uplo == 'U' || uplo == 'L' );
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(c) >= 0 );
- assert( traits::matrix_num_columns(c) >= 0 );
- assert( traits::leading_dimension(c) >= std::max(1,
+ BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(c) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(c) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
-#endif
         detail::upmtr( side, uplo, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), traits::vector_storage(ap),
                 traits::vector_storage(tau), traits::matrix_storage(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_CGESV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_CGESV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -63,22 +63,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_swork( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::cgesv( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -72,16 +72,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(ab) >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(ab) >= 2 );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(ab) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ab) >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= 2 );
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(ab) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ab)) );
-#endif
         detail::gbsv( traits::matrix_num_columns(ab), kl, ku,
                 traits::matrix_num_columns(b), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GBSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -130,24 +130,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' || fact == 'E' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::leading_dimension(afb) >= 2 );
- assert( equed == 'N' || equed == 'R' || equed == 'C' || equed == 'B' );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= 2 );
+ BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
+ equed == 'B' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::gbsvx( fact, trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(afb), traits::leading_dimension(afb),
@@ -236,24 +236,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' || fact == 'E' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( kl >= 0 );
- assert( ku >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kl+ku+1 );
- assert( traits::leading_dimension(afb) >= 2 );
- assert( equed == 'N' || equed == 'R' || equed == 'C' || equed == 'B' );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kl >= 0 );
+ BOOST_ASSERT( ku >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kl+ku+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= 2 );
+ BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
+ equed == 'B' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::gbsvx( fact, trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(afb), traits::leading_dimension(afb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -103,19 +103,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVS >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvs == 'N' || jobvs == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(wi) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::gees( jobvs, sort, select, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), sdim,
                 traits::vector_storage(wr), traits::vector_storage(wi),
@@ -191,20 +191,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVS >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvs == 'N' || jobvs == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::gees( jobvs, sort, select, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), sdim,
                 traits::vector_storage(w), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEESX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEESX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -107,22 +107,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVS >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvs == 'N' || jobvs == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(wi) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::geesx( jobvs, sort, select, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), sdim,
@@ -220,21 +221,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVS >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvs == 'N' || jobvs == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::geesx( jobvs, sort, select, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), sdim, traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -104,17 +104,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(wi) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( jobvl, jobvr, traits::matrix_num_columns(a) ));
-#endif
         detail::geev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(wr), traits::vector_storage(wi),
@@ -186,18 +186,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::geev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::vector_storage(w), traits::matrix_storage(vl),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -129,25 +129,30 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorRCONDV >::value_type >::value) );
-#ifndef NDEBUG
- assert( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
+ BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
                 balanc == 'B' );
- assert( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' || jobvl == 'B' );
- assert( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' || jobvr == 'B' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' ||
+ jobvl == 'B' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' ||
+ jobvr == 'B' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(rconde) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(rcondv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(wr) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(wi) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(rconde) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(rcondv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( sense, jobvl, jobvr,
                 traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( sense, traits::matrix_num_columns(a) ));
-#endif
         detail::geevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(wr),
@@ -262,23 +267,27 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
+ BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
                 balanc == 'B' );
- assert( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' || jobvl == 'B' );
- assert( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' || jobvr == 'B' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' ||
+ jobvl == 'B' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' ||
+ jobvr == 'B' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(rconde) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(rcondv) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(rconde) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(rcondv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( sense, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::geevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GEGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -117,19 +117,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::gegv( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -213,21 +213,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gegv( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -86,21 +86,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'T' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'T' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::gels( trans, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -155,21 +153,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( trans == 'N' || trans == 'C' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( trans == 'N' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::gels( trans, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
@@ -26,7 +27,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -104,23 +104,22 @@
         integer_t nlvl = static_cast<integer_t>(((std::log(
                 static_cast<real_type>(minmn)) /
                 std::log(static_cast<real_type>(2.))) / (smlsiz+1)) + 1);
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( minmn, smlsiz, nlvl,
                 traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( minmn, nlvl ));
-#endif
         detail::gelsd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -206,25 +205,24 @@
         integer_t nlvl = static_cast<integer_t>(((std::log(
                 static_cast<real_type>(minmn)) /
                 std::log(static_cast<real_type>(2.))) / (smlsiz+1)) + 1);
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( minmn, traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( minmn, smlsiz, nlvl,
                 traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( minmn, nlvl ));
-#endif
         detail::gelsd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -94,22 +94,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorS >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::gelss( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -173,24 +172,23 @@
                 MatrixB >::value_type >::value) );
         integer_t minmn = std::min( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 minmn ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( minmn ));
-#endif
         detail::gelss( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSY_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GELSY_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -92,20 +92,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::gelsy( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -166,22 +164,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gelsy( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -101,20 +101,20 @@
                 MatrixVT >::value_type >::value) );
         integer_t minmn = std::min( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) );
-#ifndef NDEBUG
- assert( jobz == 'A' || jobz == 'S' || jobz == 'O' || jobz == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' ||
+ jobz == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), jobz, minmn ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( minmn ));
-#endif
         detail::gesdd( jobz, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(s),
@@ -184,22 +184,22 @@
                 MatrixVT >::value_type >::value) );
         integer_t minmn = std::min( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) );
-#ifndef NDEBUG
- assert( jobz == 'A' || jobz == 'S' || jobz == 'O' || jobz == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' ||
+ jobz == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), jobz, minmn ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( minmn, jobz ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( minmn ));
-#endif
         detail::gesdd( jobz, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(s),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,15 +68,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::gesv( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,19 +98,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVT >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'A' || jobu == 'S' || jobu == 'O' || jobu == 'N' );
- assert( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' || jobvt == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' ||
+ jobu == 'N' );
+ BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' ||
+ jobvt == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) ));
-#endif
         detail::gesvd( jobu, jobvt, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(s),
@@ -176,21 +177,22 @@
                 MatrixVT >::value_type >::value) );
         integer_t minmn = std::min( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a) );
-#ifndef NDEBUG
- assert( jobu == 'A' || jobu == 'S' || jobu == 'O' || jobu == 'N' );
- assert( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' || jobvt == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' ||
+ jobu == 'N' );
+ BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' ||
+ jobvt == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
+ BOOST_ASSERT( traits::vector_size(s) >=
+ std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), minmn ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( minmn ));
-#endif
         detail::gesvd( jobu, jobvt, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(s),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GESVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -123,26 +123,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' || fact == 'E' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( equed == 'N' || equed == 'R' || equed == 'C' || equed == 'B' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
+ equed == 'B' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gesvx( fact, trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(af),
@@ -230,26 +230,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' || fact == 'E' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( equed == 'N' || equed == 'R' || equed == 'C' || equed == 'B' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' ||
+ equed == 'B' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::gesvx( fact, trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(af),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGES_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGES_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -130,22 +130,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVSR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvsl == 'N' || jobvsl == 'V' );
- assert( jobvsr == 'N' || jobvsr == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' );
+ BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(alphai) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::gges( jobvsl, jobvsr, sort, selctg,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -246,24 +246,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVSR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvsl == 'N' || jobvsl == 'V' );
- assert( jobvsr == 'N' || jobvsr == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' );
+ BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::gges( jobvsl, jobvsr, sort, selctg,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGESX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGESX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -144,25 +144,26 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorRCONDV >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvsl == 'N' || jobvsl == 'V' );
- assert( jobvsr == 'N' || jobvsr == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' );
+ BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(alphai) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -294,27 +295,28 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVSR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvsl == 'N' || jobvsl == 'V' );
- assert( jobvsr == 'N' || jobvsr == 'V' );
- assert( sort == 'N' || sort == 'S' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' );
+ BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' );
+ BOOST_ASSERT( sort == 'N' || sort == 'S' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a), sense ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- traits::matrix_num_columns(a), sort ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( traits::matrix_num_columns(a), sort ));
         detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -117,19 +117,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(alphai) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
-#endif
         detail::ggev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -213,21 +213,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::ggev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -155,27 +155,28 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorRCONDV >::value_type >::value) );
-#ifndef NDEBUG
- assert( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
+ BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
                 balanc == 'B' );
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alphar) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(alphai) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( sense, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- sense, traits::matrix_num_columns(a) ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( sense, traits::matrix_num_columns(a) ));
         detail::ggevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -323,28 +324,29 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixVR >::value_type >::value) );
-#ifndef NDEBUG
- assert( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
+ BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' ||
                 balanc == 'B' );
- assert( jobvl == 'N' || jobvl == 'V' );
- assert( jobvr == 'N' || jobvr == 'V' );
- assert( sense == 'N' || sense == 'E' || sense == 'V' || sense == 'B' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' );
+ BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' );
+ BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' ||
+ sense == 'B' );
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(beta) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( sense, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( balanc, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( sense, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
- sense, traits::matrix_num_columns(a) ));
-#endif
+ BOOST_ASSERT( traits::vector_size(work.select(bool())) >=
+ min_size_bwork( sense, traits::matrix_num_columns(a) ));
         detail::ggevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGGLM_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGGLM_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -100,21 +100,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorY >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >=
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >=
                 traits::matrix_num_rows(b)-traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(y) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(d) >= traits::matrix_num_rows(b) );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(y) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b) ));
-#endif
         detail::ggglm( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -183,21 +183,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorY >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::matrix_num_columns(b) >=
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >=
                 traits::matrix_num_rows(b)-traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(y) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(d) >= traits::matrix_num_rows(b) );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(y) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b) ));
-#endif
         detail::ggglm( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGLSE_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGLSE_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -25,7 +26,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -100,20 +100,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(c) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(c) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(d) >= traits::matrix_num_rows(b) );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b) ));
-#endif
         detail::gglse( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -182,20 +181,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(c) >= traits::matrix_num_rows(a) );
- assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
- assert( traits::vector_size(x) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(c) >= traits::matrix_num_rows(a) );
+ BOOST_ASSERT( traits::vector_size(d) >= traits::matrix_num_rows(b) );
+ BOOST_ASSERT( traits::vector_size(x) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b) ));
-#endif
         detail::gglse( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GGSVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GGSVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -127,24 +127,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
                 traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(b) ));
-#endif
         detail::ggsvd( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b), k,
                 l, traits::matrix_storage(a), traits::leading_dimension(a),
@@ -227,26 +226,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixQ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobu == 'U' || jobu == 'N' );
- assert( jobv == 'V' || jobv == 'N' );
- assert( jobq == 'Q' || jobq == 'N' );
- assert( traits::matrix_num_rows(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::matrix_num_rows(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
+ BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
+ BOOST_ASSERT( jobq == 'Q' || jobq == 'N' );
+ BOOST_ASSERT( traits::matrix_num_rows(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_rows(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
- assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(alpha) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
                 traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(b) ));
-#endif
         detail::ggsvd( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b), k,
                 l, traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GTSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GTSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -79,14 +79,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::gtsv( n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GTSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_GTSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -140,22 +140,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::gtsvx( fact, trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::vector_storage(dlf),
@@ -254,22 +253,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorDL >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( trans == 'N' || trans == 'T' || trans == 'C' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(dl) >= n-1 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(du) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( trans == 'N' || trans == 'T' || trans == 'C' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(dl) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(du) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(b) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::gtsvx( fact, trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
                 traits::vector_storage(du), traits::vector_storage(dlf),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,18 +66,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hbev( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBEVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBEVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,20 +71,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::hbevd( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -83,23 +83,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::leading_dimension(q) >= std::max(1,n) );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::hbevx( jobz, range, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(q), traits::leading_dimension(q), vl,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -74,20 +74,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hbgv( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBGVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBGVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -79,22 +79,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::hbgvd( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBGVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HBGVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -90,23 +90,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::hbgvx( jobz, range, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -61,18 +61,16 @@
             typename RWORK >
     static void compute( char const jobz, MatrixA& a, VectorW& w,
             integer_t& info, detail::workspace2< WORK, RWORK > work ) {
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::heev( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -65,20 +65,18 @@
             typename RWORK, typename IWORK >
     static void compute( char const jobz, MatrixA& a, VectorW& w,
             integer_t& info, detail::workspace3< WORK, RWORK, IWORK > work ) {
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, traits::matrix_num_columns(a) ));
-#endif
         detail::heevd( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEVR_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEVR_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -80,23 +80,22 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(isuppz) >= 2*std::max(1,m) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(isuppz) >= 2*std::max(1,m) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::heevr( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -78,22 +78,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(w) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::heevx( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
                 traits::leading_dimension(a), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,18 +69,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hegv( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEGVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEGVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,20 +71,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::hegvd( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEGVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HEGVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -87,22 +87,20 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( n >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,n) );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::hegvx( itype, jobz, range, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
                 traits::matrix_storage(b), traits::leading_dimension(b), vl,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,18 +66,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( ));
-#endif
         detail::hesv( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HESVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HESVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -86,26 +86,25 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::hesvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -66,16 +66,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hpev( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),
                 traits::matrix_storage(z), traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPEVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPEVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -69,18 +69,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::hpevd( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),
                 traits::matrix_storage(z), traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -74,19 +74,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::hpevx( jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), vl, vu, il, iu, abstol, m,
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -70,16 +70,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hpgv( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPGVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPGVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -77,18 +77,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::hpgvd( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPGVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPGVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,20 +82,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::hpgvx( itype, jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp), vl,
                 vu, il, iu, abstol, m, traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -58,14 +58,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
-#endif
         detail::hpsv( traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_HPSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -83,20 +83,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::hpsvx( fact, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
                 traits::matrix_storage(afp), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LACGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LACGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -51,9 +51,7 @@
     template< typename VectorX >
     static void compute( integer_t const n, VectorX& x,
             integer_t const incx ) {
-#ifndef NDEBUG
- assert( n >= 0 );
-#endif
+ BOOST_ASSERT( n >= 0 );
         detail::lacgv( n, traits::vector_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LALSD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LALSD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -98,18 +98,16 @@
             std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+
                     1)) /
             std::log(static_cast<real_type>(2.)) ) + 1 );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 1 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 1 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n, smlsiz, nlvl,
                 traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n, nlvl ));
-#endif
         detail::lalsd( uplo, smlsiz, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -180,20 +178,18 @@
                     n))/
             static_cast<real_type>(smlsiz+1)) /
             std::log(static_cast<real_type>(2.))) + 1 );
-#ifndef NDEBUG
- assert( uplo == 'U' || uplo == 'L' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 1 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( uplo == 'U' || uplo == 'L' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 1 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n, traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n, smlsiz, nlvl,
                 traits::matrix_num_columns(b) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n, nlvl ));
-#endif
         detail::lalsd( uplo, smlsiz, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LARGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_LARGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -78,11 +78,9 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorX >::value_type, typename traits::vector_traits<
                 VectorC >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::vector_size(x) >= 1+(n-1)*incx );
- assert( traits::vector_size(y) >= 1+(n-1)*incy );
- assert( traits::vector_size(c) >= 1+(n-1)*incc );
-#endif
+ BOOST_ASSERT( traits::vector_size(x) >= 1+(n-1)*incx );
+ BOOST_ASSERT( traits::vector_size(y) >= 1+(n-1)*incy );
+ BOOST_ASSERT( traits::vector_size(c) >= 1+(n-1)*incc );
         detail::largv( n, traits::vector_storage(x), incx,
                 traits::vector_storage(y), incy, traits::vector_storage(c),
                 incc );
@@ -104,11 +102,9 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorX >::value_type, typename traits::vector_traits<
                 VectorY >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::vector_size(x) >= 1+(n-1)*incx );
- assert( traits::vector_size(y) >= 1+(n-1)*incy );
- assert( traits::vector_size(c) >= 1+(n-1)*incc );
-#endif
+ BOOST_ASSERT( traits::vector_size(x) >= 1+(n-1)*incx );
+ BOOST_ASSERT( traits::vector_size(y) >= 1+(n-1)*incy );
+ BOOST_ASSERT( traits::vector_size(c) >= 1+(n-1)*incc );
         detail::largv( n, traits::vector_storage(x), incx,
                 traits::vector_storage(y), incy, traits::vector_storage(c),
                 incc );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,16 +68,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( traits::matrix_num_columns(ab) >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ab) >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ab)) );
-#endif
         detail::pbsv( traits::matrix_uplo_tag(ab),
                 traits::matrix_num_columns(ab), kd,
                 traits::matrix_num_columns(b), traits::matrix_storage(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PBSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PBSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -119,24 +119,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(afb) >= kd+1 );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= kd+1 );
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::pbsvx( fact, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(afb),
@@ -217,24 +217,24 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(ab) >= kd+1 );
- assert( traits::leading_dimension(afb) >= kd+1 );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd+1 );
+ BOOST_ASSERT( traits::leading_dimension(afb) >= kd+1 );
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::pbsvx( fact, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::matrix_storage(afb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -67,16 +67,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-#endif
         detail::posv( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_POSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -116,27 +116,27 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(a) ));
-#endif
         detail::posvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -216,27 +216,27 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(a) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
                 traits::matrix_uplo_tag(a) == 'L' );
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(af) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(a) ));
-#endif
         detail::posvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -67,14 +67,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
-#endif
         detail::ppsv( traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::matrix_storage(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PPSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -112,23 +112,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(ap) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(ap) ));
-#endif
         detail::ppsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::vector_storage(afp),
@@ -207,23 +207,23 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'Y' || fact == 'N' || fact == 'E' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
+ fact == 'E' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( equed == 'N' || equed == 'Y' );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( equed == 'N' || equed == 'Y' );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(ap) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(ap) ));
-#endif
         detail::ppsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::vector_storage(afp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PTSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PTSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/is_complex.hpp>
 #include <boost/numeric/bindings/traits/is_real.hpp>
@@ -22,7 +23,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -76,13 +76,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::ptsv( n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(b),
@@ -104,13 +102,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorE >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( n >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
-#endif
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
         detail::ptsv( n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::matrix_storage(b), traits::leading_dimension(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 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PTSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_PTSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -115,18 +115,17 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::ptsvx( fact, n, traits::matrix_num_columns(x),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::vector_storage(df), traits::vector_storage(ef),
@@ -201,20 +200,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorE >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( n >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::vector_size(d) >= n );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::leading_dimension(b) >= std::max(1,n) );
- assert( traits::leading_dimension(x) >= std::max(1,n) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::vector_size(d) >= n );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n ));
-#endif
         detail::ptsvx( fact, n, traits::matrix_num_columns(x),
                 traits::vector_storage(d), traits::vector_storage(e),
                 traits::vector_storage(df), traits::vector_storage(ef),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -65,16 +65,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::sbev( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBEVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBEVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -70,18 +70,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::sbevd( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -82,21 +82,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( kd >= 0 );
- assert( traits::leading_dimension(ab) >= kd );
- assert( traits::leading_dimension(q) >= std::max(1,n) );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( kd >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= kd );
+ BOOST_ASSERT( traits::leading_dimension(q) >= std::max(1,n) );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::sbevx( jobz, range, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(q), traits::leading_dimension(q), vl,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -71,18 +71,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::sbgv( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBGVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBGVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -75,20 +75,18 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::sbgvd( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SBGVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SBGVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -87,21 +87,19 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAB >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ab) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ab) == 'U' ||
                 traits::matrix_uplo_tag(ab) == 'L' );
- assert( n >= 0 );
- assert( ka >= 0 );
- assert( kb >= 0 );
- assert( traits::leading_dimension(ab) >= ka+1 );
- assert( traits::leading_dimension(bb) >= kb+1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( ka >= 0 );
+ BOOST_ASSERT( kb >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(ab) >= ka+1 );
+ BOOST_ASSERT( traits::leading_dimension(bb) >= kb+1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::sbgvx( jobz, range, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
                 traits::matrix_storage(bb), traits::leading_dimension(bb),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SGESV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SGESV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -60,22 +60,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixA >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_num_columns(a) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(a) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::vector_size(ipiv) >=
+ traits::matrix_num_columns(a) );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( $CALL_MIN_SIZE ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_swork( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b) ));
-#endif
         detail::sgesv( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -63,14 +63,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::spev( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),
                 traits::matrix_storage(z), traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPEVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPEVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,16 +68,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::spevd( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),
                 traits::matrix_storage(z), traits::leading_dimension(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPEVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPEVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -73,17 +73,15 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::spevx( jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), vl, vu, il, iu, abstol, m,
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPGV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPGV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,14 +68,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::spgv( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPGVD_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPGVD_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -22,7 +23,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -74,16 +74,14 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( jobz, n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( jobz, n ));
-#endif
         detail::spgvd( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),
                 traits::vector_storage(w), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPGVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPGVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -78,18 +78,16 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( range == 'A' || range == 'V' || range == 'I' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( n >= 0 );
- assert( traits::vector_size(w) >= n );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(w) >= n );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( n ));
-#endif
         detail::spgvx( itype, jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp), vl,
                 vu, il, iu, abstol, m, traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsv.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,12 +14,12 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/traits/traits.hpp>
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -68,14 +68,12 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixB >::value_type >::value) );
-#ifndef NDEBUG
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(b) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(b) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
-#endif
         detail::spsv( traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(b),
                 traits::matrix_storage(ap), traits::vector_storage(ipiv),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPSVX_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_SPSVX_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -24,7 +25,6 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -109,22 +109,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::vector_traits<
                 VectorBERR >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( traits::matrix_num_columns(ap) ));
- assert( traits::vector_size(work.select(integer_t())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
                 min_size_iwork( traits::matrix_num_columns(ap) ));
-#endif
         detail::spsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(afp),
@@ -200,22 +199,21 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
                 MatrixAP >::value_type, typename traits::matrix_traits<
                 MatrixX >::value_type >::value) );
-#ifndef NDEBUG
- assert( fact == 'F' || fact == 'N' );
- assert( traits::matrix_uplo_tag(ap) == 'U' ||
+ BOOST_ASSERT( fact == 'F' || fact == 'N' );
+ BOOST_ASSERT( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
- assert( traits::matrix_num_columns(ap) >= 0 );
- assert( traits::matrix_num_columns(x) >= 0 );
- assert( traits::leading_dimension(b) >= std::max(1,
+ BOOST_ASSERT( traits::matrix_num_columns(ap) >= 0 );
+ BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
+ BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::leading_dimension(x) >= std::max(1,
+ BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
- assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
- assert( traits::vector_size(work.select(value_type())) >=
+ BOOST_ASSERT( traits::vector_size(berr) >=
+ traits::matrix_num_columns(x) );
+ BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(ap) ));
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( traits::matrix_num_columns(ap) ));
-#endif
         detail::spsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(afp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp 2009-03-09 15:30:03 EDT (Mon, 09 Mar 2009)
@@ -14,6 +14,7 @@
 #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_STEV_HPP
 #define BOOST_NUMERIC_BINDINGS_LAPACK_STEV_HPP
 
+#include <boost/assert.hpp>
 #include <boost/numeric/bindings/lapack/lapack.h>
 #include <boost/numeric/bindings/lapack/workspace.hpp>
 #include <boost/numeric/bindings/traits/detail/array.hpp>
@@ -21,7 +22,6 @@
 #include <boost/numeric/bindings/traits/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <cassert>
 
 namespace boost {
 namespace numeric {
@@ -62,13 +62,11 @@
         BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
                 VectorD >::value_type, typename traits::matrix_traits<
                 MatrixZ >::value_type >::value) );
-#ifndef NDEBUG
- assert( jobz == 'N' || jobz == 'V' );
- assert( n >= 0 );
- assert( traits::vector_size(e) >= n-1 );
- assert( traits::vector_size(work.select(real_type())) >=
+ BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
+ BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( traits::vector_size(e) >= n-1 );
+ BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
                 min_size_work( n ));
-#endif
         detail::stev( jobz, n, traits::vector_s