Index: /XMLIO_V2/external/include/blitz/applics.h
===================================================================
--- /XMLIO_V2/external/include/blitz/applics.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/applics.h	(revision 73)
@@ -0,0 +1,407 @@
+/***************************************************************************
+ * blitz/applics.h      Applicative template classes
+ *
+ * $Id: applics.h,v 1.5 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org    
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_APPLICS_H
+#define BZ_APPLICS_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_PROMOTE_H
+ #include <blitz/promote.h>
+#endif
+
+#ifndef BZ_NUMTRAIT_H
+ #include <blitz/numtrait.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// These base classes are included for no other reason than to keep
+// the applicative templates clustered together in a graphical
+// class browser.
+class ApplicativeTemplatesBase { };
+class TwoOperandApplicativeTemplatesBase : public ApplicativeTemplatesBase { };
+class OneOperandApplicativeTemplatesBase : public ApplicativeTemplatesBase { };
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Add : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote; 
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x + y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Subtract : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+ 
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x - y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Multiply : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x * y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Divide : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x / y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Mod : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x % y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_BitwiseXOR : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x ^ y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_BitwiseAnd : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x & y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_BitwiseOr : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x | y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_ShiftRight : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x >> y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_ShiftLeft : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x << y; }
+};
+
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Min : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return (x < y ? x : y); }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Max : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1,T_numtype2) T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return (x > y ? x : y); }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Greater : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x > y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Less : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x < y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_GreaterOrEqual : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x >= y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_LessOrEqual : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x <= y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_Equal : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x == y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_NotEqual : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x != y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_LogicalAnd : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x && y; }
+};
+
+template<typename P_numtype1, typename P_numtype2>
+class _bz_LogicalOr : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef bool       T_promote;
+    typedef T_promote  T_numtype;
+
+    static inline T_promote apply(P_numtype1 x, P_numtype2 y)
+    { return x || y; }
+};
+
+
+template<typename P_numtype_in, typename P_numtype_out>
+class _bz_Cast : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype_in T_numtype1;
+    typedef P_numtype_out T_promote;
+    typedef T_promote     T_numtype;
+
+    static inline P_numtype_out apply(P_numtype_in x)
+    { return P_numtype_out(x); }
+};
+
+template<typename P_numtype>
+class _bz_LogicalNot : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype T_numtype1;
+    typedef bool      T_promote;
+    typedef T_promote T_numtype;
+
+    static inline P_numtype apply(P_numtype x)
+    { return !x; }
+};
+
+template<typename P_numtype>
+class _bz_BitwiseNot : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype     T_numtype1;
+    typedef T_numtype1    T_promote;
+    typedef T_promote     T_numtype;
+
+    static inline P_numtype apply(P_numtype x)
+    { return ~x; }
+};
+
+
+
+/*****************************************************************************
+ * Math Functions
+ *****************************************************************************/
+
+// Applicative templates for these functions are defined in
+// <blitz/mathfunc.h>, which is included below:
+//
+// abs(i), labs(l)                     Absolute value
+// acos(d), acols(ld)                  Inverse cosine
+// acosh(d)                            Inverse hyperbolic cosine
+// asin(d), asinl(ld)                  Inverse sine
+// asinh(d)                            Inverse hyperbolic sine
+// atan(d), atanl(ld)                  Inverse tangent
+// atan2(d,d), atan2l(ld,ld)           Inverse tangent
+// atanh(d)                            Inverse hyperbolic tangent
+// cbrt(x)                             Cube root
+// ceil(d), ceill(ld)                  Smallest f-int not less than x
+// int class(d)                        Classification of x (FP_XXXXX)
+// cos(d), cosl(ld)                    Cosine
+// cosh(d), coshl(ld)                  Hyperbolic cosine
+// copysign(d,d)                       Return 1st arg with same sign as 2nd
+// drem(x,x)                           IEEE remainder
+// exp(d), expl(ld)                    Exponential
+// expm1(d)                            Exp(x)-1     
+// erf(d), erfl(ld)                    Error function
+// erfc(d), erfcl(ld)                  Complementary error function
+// fabs(d), fabsl(ld)                  Floating point absolute value
+// int finite(d)                       Nonzero if finite
+// floor(d), floor(ld)                 Largest f-int not greater than x
+// fmod(d,d), fmodl(ld,ld)             Floating point remainder
+// frexp(d, int* e)                    Break into mantissa/exponent  (*)
+// frexpl(ld, int* e)                  Break into mantissa/exponent  (*)
+// gammaFunc(d)                        Gamma function (** needs special 
+//                                     implementation using lgamma)
+// hypot(d,d)                          Hypotenuse: sqrt(x*x+y*y)
+// int ilogb(d)                        Integer unbiased exponent
+// int isnan(d)                        Nonzero if NaNS or NaNQ
+// int itrunc(d)                       Truncate and convert to integer
+// j0(d)                               Bessel function first kind, order 0
+// j1(d)                               Bessel function first kind, order 1
+// jn(int, double)                     Bessel function first kind, order i
+// ldexp(d,i), ldexpl(ld,i)            Compute d * 2^i
+// lgamma(d), lgammald(ld)             Log absolute gamma
+// log(d), logl(ld)                    Natural logarithm
+// logb(d)                             Unbiased exponent (IEEE)
+// log1p(d)                            Compute log(1 + x)
+// log10(d), log10l(ld)                Logarithm base 10
+// modf(d, int* i), modfl(ld, int* i)  Break into integral/fractional part
+// double nearest(double)              Nearest floating point integer
+// nextafter(d, d)                     Next representable neighbor of 1st
+//                                     in direction of 2nd
+// pow(d,d), pow(ld,ld)                Computes x ^ y
+// d remainder(d,d)                    IEEE remainder
+// d rint(d)                           Round to f-integer (depends on mode)
+// d rsqrt(d)                          Reciprocal square root
+// d scalb(d,d)                        Return x * (2^y)
+// sin(d), sinl(ld)                    Sine 
+// sinh(d), sinhl(ld)                  Hyperbolic sine
+// sqr(x)                              Return x * x
+// sqrt(d), sqrtl(ld)                  Square root
+// tan(d), tanl(ld)                    Tangent
+// tanh(d), tanhl(ld)                  Hyperbolic tangent
+// trunc(d)                            Nearest f-int in the direction of 0
+// unsigned uitrunc(d)                 Truncate and convert to unsigned
+// int unordered(d,d)                  Nonzero if comparison is unordered
+// y0(d)                               Bessel function 2nd kind, order 0
+// y1(d)                               Bessel function 2nd kind, order 1
+// yn(i,d)                             Bessel function 2nd kind, order d
+
+
+BZ_NAMESPACE_END
+
+#ifndef BZ_MATHFUNC_H
+ #include <blitz/mathfunc.h>
+#endif
+
+#ifndef BZ_MATHF2_H
+ #include <blitz/mathf2.h>
+#endif
+
+#endif // BZ_APPLICS_H
Index: /XMLIO_V2/external/include/blitz/array-impl.h
===================================================================
--- /XMLIO_V2/external/include/blitz/array-impl.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/array-impl.h	(revision 73)
@@ -0,0 +1,2527 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/array-impl.h    Definition of the Array<P_numtype, N_rank> class
+ *
+ * $Id: array-impl.h,v 1.25 2005/10/13 23:46:43 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+/*
+ * Wish list for array classes.
+ *  - Arrays whose dimensions are unknown at compile time.
+ *  - where()/elsewhere()/elsewhere() as in Dan Quinlan's implementation
+ *  - block reduction operations
+ *  - conversion to/from matrix & vector
+ *  - apply(T func(T))
+ *  - apply(T func(const T&))
+ *  - apply<T func(T)>
+ */
+
+#ifndef BZ_ARRAY_H
+#define BZ_ARRAY_H
+
+#include <blitz/blitz.h>
+#include <blitz/memblock.h>
+#include <blitz/range.h>
+#include <blitz/tinyvec.h>
+
+#ifdef BZ_ARRAY_SPACE_FILLING_TRAVERSAL
+#include <blitz/traversal.h>
+#endif
+
+#include <blitz/indexexpr.h>
+#include <blitz/prettyprint.h>
+
+#include <blitz/array/slice.h>     // Subarrays and slicing
+#include <blitz/array/map.h>       // Tensor index notation
+#include <blitz/array/multi.h>     // Multicomponent arrays
+#include <blitz/array/domain.h>    // RectDomain class
+#include <blitz/array/storage.h>   // GeneralArrayStorage
+
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * Forward declarations
+ */
+
+template<typename T_numtype, int N_rank>
+class ArrayIterator;
+
+template<typename T_numtype, int N_rank>
+class ConstArrayIterator;
+
+template<typename T_numtype, int N_rank>
+class FastArrayIterator;
+
+template<typename P_expr>
+class _bz_ArrayExpr;
+
+template<typename T_array, typename T_index>
+class IndirectArray;
+
+template <typename P_numtype,int N_rank>
+void swap(Array<P_numtype,N_rank>&,Array<P_numtype,N_rank>&);
+
+template <typename P_numtype, int N_rank>
+void find(Array<TinyVector<int,N_rank>,1>&,const Array<P_numtype,N_rank>&);
+
+/*
+ * Declaration of class Array
+ */
+
+// NEEDS_WORK: Array should inherit protected from MemoryBlockReference.
+// To make this work, need to expose MemoryBlockReference::numReferences()
+// and make Array<P,N2> a friend of Array<P,N> for slicing.
+
+template<typename P_numtype, int N_rank>
+class Array : public MemoryBlockReference<P_numtype> 
+#ifdef BZ_NEW_EXPRESSION_TEMPLATES
+    , public ETBase<Array<P_numtype,N_rank> >
+#endif
+{
+
+private:
+    typedef MemoryBlockReference<P_numtype> T_base;
+    using T_base::data_;
+    using T_base::changeToNullBlock;
+    using T_base::numReferences;
+
+public:
+    //////////////////////////////////////////////
+    // Public Types
+    //////////////////////////////////////////////
+
+    /*
+     * T_numtype  is the numeric type stored in the array.
+     * T_index    is a vector type which can be used to access elements
+     *            of many-dimensional arrays.
+     * T_array    is the array type itself -- Array<T_numtype, N_rank>
+     * T_iterator is a a fast iterator for the array, used for expression
+     *            templates
+     * iterator   is a STL-style iterator
+     * const_iterator is an STL-style const iterator
+     */
+
+    typedef P_numtype                T_numtype;
+    typedef TinyVector<int, N_rank>  T_index;
+    typedef Array<T_numtype, N_rank> T_array;
+    typedef FastArrayIterator<T_numtype, N_rank> T_iterator;
+
+    typedef ArrayIterator<T_numtype,N_rank> iterator;
+    typedef ConstArrayIterator<T_numtype,N_rank> const_iterator;
+
+    static const int _bz_rank = N_rank;
+
+    //////////////////////////////////////////////
+    // Constructors                             //
+    //////////////////////////////////////////////
+
+    
+    /*
+     * Construct an array from an array expression.
+     */
+
+    template<typename T_expr>
+    explicit Array(_bz_ArrayExpr<T_expr> expr);
+
+    /*
+     * Any missing length arguments will have their value taken from the
+     * last argument.  For example,
+     *   Array<int,3> A(32,64);
+     * will create a 32x64x64 array.  This is handled by setupStorage().
+     */
+
+    Array(GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        length_ = 0;
+        stride_ = 0;
+        zeroOffset_ = 0;
+    }
+
+    explicit Array(int length0, 
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        length_[0] = length0;
+        setupStorage(0);
+    }
+
+    Array(int length0, int length1,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 2);
+        TAU_TYPE_STRING(p1, "Array<T,N>::Array() [T="
+            + CT(T_numtype) + ",N=" + CT(N_rank) + "]");
+        TAU_PROFILE(p1, "void (int,int)", TAU_BLITZ);
+
+        length_[0] = length0;
+        length_[1] = length1;
+        setupStorage(1);
+    }
+
+    Array(int length0, int length1, int length2,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 3);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        setupStorage(2);
+    }
+
+    Array(int length0, int length1, int length2, int length3,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 4);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        setupStorage(3);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 5);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        setupStorage(4);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 6);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        setupStorage(5);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5, int length6,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 7);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        length_[6] = length6;
+        setupStorage(6);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5, int length6, int length7,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 8);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        length_[6] = length6;
+        length_[7] = length7;
+        setupStorage(7);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5, int length6, int length7, int length8,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 9);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        length_[6] = length6;
+        length_[7] = length7;
+        length_[8] = length8;
+        setupStorage(8);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5, int length6, int length7, int length8, int length9,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 10);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        length_[6] = length6;
+        length_[7] = length7;
+        length_[8] = length8;
+        length_[9] = length9;
+        setupStorage(9);
+    }
+
+    Array(int length0, int length1, int length2, int length3, int length4,
+        int length5, int length6, int length7, int length8, int length9,
+        int length10,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(N_rank >= 11);
+        length_[0] = length0;
+        length_[1] = length1;
+        length_[2] = length2;
+        length_[3] = length3;
+        length_[4] = length4;
+        length_[5] = length5;
+        length_[6] = length6;
+        length_[7] = length7;
+        length_[8] = length8;
+        length_[9] = length9;
+        length_[10] = length10;
+        setupStorage(10);
+    }
+
+    /*
+     * Construct an array from an existing block of memory.  Ownership
+     * is not acquired (this is provided for backwards compatibility).
+     */
+    Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+      : MemoryBlockReference<T_numtype>(product(shape), dataFirst, 
+          neverDeleteData),
+        storage_(storage)
+    {
+        BZPRECONDITION(dataFirst != 0);
+
+        length_ = shape;
+        computeStrides();
+        data_ += zeroOffset_;
+    }
+
+    /*
+     * Construct an array from an existing block of memory, with a
+     * given set of strides.  Ownership is not acquired (i.e. the memory
+     * block will not be freed by Blitz++).
+     */
+    Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
+        TinyVector<int, N_rank> stride, 
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+      : MemoryBlockReference<T_numtype>(product(shape), dataFirst, 
+          neverDeleteData),
+        storage_(storage)
+    {
+        BZPRECONDITION(dataFirst != 0);
+
+        length_ = shape;
+        stride_ = stride;
+        calculateZeroOffset();
+        data_ += zeroOffset_;
+    }
+
+    /*
+     * Construct an array from an existing block of memory.
+     */
+    Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
+        preexistingMemoryPolicy deletionPolicy,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+      : MemoryBlockReference<T_numtype>(product(shape), dataFirst, 
+            deletionPolicy),
+        storage_(storage)
+    {
+        BZPRECONDITION(dataFirst != 0);
+
+        length_ = shape;
+        computeStrides();
+        data_ += zeroOffset_;
+
+        if (deletionPolicy == duplicateData)
+            reference(copy());
+    }
+
+    /*
+     * Construct an array from an existing block of memory, with a
+     * given set of strides.  
+     */
+    Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
+        TinyVector<int, N_rank> stride,
+        preexistingMemoryPolicy deletionPolicy,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+      : MemoryBlockReference<T_numtype>(product(shape), dataFirst, 
+          deletionPolicy),
+        storage_(storage)
+    {
+        BZPRECONDITION(dataFirst != 0);
+
+        length_ = shape;
+        stride_ = stride;
+        calculateZeroOffset();
+        data_ += zeroOffset_;
+
+        if (deletionPolicy == duplicateData)
+            reference(copy());
+    }
+
+    /*
+     * This constructor takes an extent (length) vector and storage format.
+     */
+
+    Array(const TinyVector<int, N_rank>& extent, 
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        length_ = extent;
+        setupStorage(N_rank - 1);
+    }
+
+    /*
+     * This construct takes a vector of bases (lbounds) and a vector of
+     * extents.
+     */
+
+    Array(const TinyVector<int, N_rank>& lbounds,
+        const TinyVector<int, N_rank>& extent,
+        const GeneralArrayStorage<N_rank>& storage 
+           = GeneralArrayStorage<N_rank>());
+
+    /*
+     * These constructors allow arbitrary bases (starting indices) to be set.
+     * e.g. Array<int,2> A(Range(10,20), Range(20,30))
+     * will create an 11x11 array whose indices are 10..20 and 20..30
+     */
+    Array(Range r0, 
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        setupStorage(0);
+    }
+
+    Array(Range r0, Range r1,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() && 
+            r1.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+
+        setupStorage(1);
+    }
+
+    Array(Range r0, Range r1, Range r2,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+
+        setupStorage(2);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+
+        setupStorage(3);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+
+        setupStorage(4);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+
+        setupStorage(5);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        Range r6,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous() && r6.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+        length_[6] = r6.length();
+        storage_.setBase(6, r6.first());
+
+        setupStorage(6);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        Range r6, Range r7,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous() && r6.isAscendingContiguous()
+            && r7.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+        length_[6] = r6.length();
+        storage_.setBase(6, r6.first());
+        length_[7] = r7.length();
+        storage_.setBase(7, r7.first());
+
+        setupStorage(7);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        Range r6, Range r7, Range r8,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous() && r6.isAscendingContiguous()
+            && r7.isAscendingContiguous() && r8.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+        length_[6] = r6.length();
+        storage_.setBase(6, r6.first());
+        length_[7] = r7.length();
+        storage_.setBase(7, r7.first());
+        length_[8] = r8.length();
+        storage_.setBase(8, r8.first());
+
+        setupStorage(8);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        Range r6, Range r7, Range r8, Range r9,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous() && r6.isAscendingContiguous()
+            && r7.isAscendingContiguous() && r8.isAscendingContiguous()
+            && r9.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+        length_[6] = r6.length();
+        storage_.setBase(6, r6.first());
+        length_[7] = r7.length();
+        storage_.setBase(7, r7.first());
+        length_[8] = r8.length();
+        storage_.setBase(8, r8.first());
+        length_[9] = r9.length();
+        storage_.setBase(9, r9.first());
+
+        setupStorage(9);
+    }
+
+    Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
+        Range r6, Range r7, Range r8, Range r9, Range r10,
+        GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
+        : storage_(storage)
+    {
+        BZPRECONDITION(r0.isAscendingContiguous() &&
+            r1.isAscendingContiguous() && r2.isAscendingContiguous()
+            && r3.isAscendingContiguous() && r4.isAscendingContiguous()
+            && r5.isAscendingContiguous() && r6.isAscendingContiguous()
+            && r7.isAscendingContiguous() && r8.isAscendingContiguous()
+            && r9.isAscendingContiguous() && r10.isAscendingContiguous());
+
+        length_[0] = r0.length();
+        storage_.setBase(0, r0.first());
+        length_[1] = r1.length();
+        storage_.setBase(1, r1.first());
+        length_[2] = r2.length();
+        storage_.setBase(2, r2.first());
+        length_[3] = r3.length();
+        storage_.setBase(3, r3.first());
+        length_[4] = r4.length();
+        storage_.setBase(4, r4.first());
+        length_[5] = r5.length();
+        storage_.setBase(5, r5.first());
+        length_[6] = r6.length();
+        storage_.setBase(6, r6.first());
+        length_[7] = r7.length();
+        storage_.setBase(7, r7.first());
+        length_[8] = r8.length();
+        storage_.setBase(8, r8.first());
+        length_[9] = r9.length();
+        storage_.setBase(9, r9.first());
+        length_[10] = r10.length();
+        storage_.setBase(10, r10.first());
+
+        setupStorage(10);
+    }
+
+    /*
+     * Create a reference of another array
+     */
+    Array(const Array<T_numtype, N_rank>& array)
+#ifdef BZ_NEW_EXPRESSION_TEMPLATES
+        : MemoryBlockReference<T_numtype>(),
+          ETBase< Array<T_numtype, N_rank> >(array)
+#else
+        : MemoryBlockReference<T_numtype>()
+#endif
+    {
+        // NEEDS_WORK: this const_cast is a tad ugly.
+        reference(const_cast<T_array&>(array));
+    }
+
+    /*
+     * These constructors are used for creating interlaced arrays (see
+     * <blitz/arrayshape.h>
+     */
+    Array(const TinyVector<int,N_rank-1>& shape,
+        int lastExtent, const GeneralArrayStorage<N_rank>& storage);
+    //Array(const TinyVector<Range,N_rank-1>& shape,
+    //    int lastExtent, const GeneralArrayStorage<N_rank>& storage);
+
+    /*
+     * These constructors make the array a view of a subportion of another
+     * array.  If there fewer than N_rank Range arguments provided, no
+     * slicing is performed in the unspecified ranks.
+     * e.g. Array<int,3> A(20,20,20);
+     *      Array<int,3> B(A, Range(5,15));
+     * is equivalent to:
+     *      Array<int,3> B(A, Range(5,15), Range::all(), Range::all());
+     */
+    Array(Array<T_numtype, N_rank>& array, Range r0)
+    {
+        constructSubarray(array, r0);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1)
+    {
+        constructSubarray(array, r0, r1);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2)
+    {
+        constructSubarray(array, r0, r1, r2);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3)
+    {
+        constructSubarray(array, r0, r1, r2, r3);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5, Range r6)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5, r6);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5, Range r6, Range r7)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
+        Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9,
+        Range r10)
+    {
+        constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
+    }
+
+    Array(Array<T_numtype, N_rank>& array, 
+        const RectDomain<N_rank>& subdomain)
+    {
+        constructSubarray(array, subdomain);
+    }
+
+    /* Constructor added by Julian Cummings */
+    Array(Array<T_numtype, N_rank>& array, 
+        const StridedDomain<N_rank>& subdomain)
+    {
+        constructSubarray(array, subdomain);
+    }
+
+    /*
+     * This constructor is invoked by the operator()'s which take
+     * a combination of integer and Range arguments.  It's not intended
+     * for end-user use.
+     */
+    template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4,
+        typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
+    Array(Array<T_numtype,N_rank2>& array, R0 r0, R1 r1, R2 r2,
+        R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
+    {
+        constructSlice(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
+    }
+
+    //////////////////////////////////////////////
+    // Member functions
+    //////////////////////////////////////////////
+
+    const TinyVector<int, N_rank>&    base() const
+    { return storage_.base(); }
+
+    int                               base(int rank) const
+    { return storage_.base(rank); }
+
+    iterator                          begin() 
+    { return iterator(*this); }
+
+    const_iterator                    begin() const
+    { return const_iterator(*this); }
+
+    T_iterator                        beginFast() const
+    { return T_iterator(*this); }
+
+    // Deprecated: now extractComponent(...)
+    template<typename P_numtype2>
+    Array<P_numtype2,N_rank>          chopComponent(P_numtype2 a, int compNum,
+                                          int numComponents) const
+    { return extractComponent(a, compNum, numComponents); }
+
+    int                               cols() const
+    { return length_[1]; }
+
+    int                               columns() const
+    { return length_[1]; }
+
+    T_array                           copy() const;
+
+    // data_ always refers to the point (0,0,...,0) which may
+    // not be in the array if the base is not zero in each rank.
+    // These data() routines return a pointer to the first
+    // element in the array (but note that it may not be
+    // stored first in memory if some ranks are stored descending).
+
+    int                               dataOffset() const
+    {
+        return dot(storage_.base(), stride_);
+    }
+
+    const T_numtype* restrict     data() const
+    { return data_ + dataOffset(); }
+
+    T_numtype* restrict           data() 
+    { return data_ + dataOffset(); }
+
+    // These dataZero() routines refer to the point (0,0,...,0)
+    // which may not be in the array if the bases are nonzero.
+    
+    const T_numtype* restrict     dataZero() const
+    { return data_; }
+
+    T_numtype* restrict           dataZero()
+    { return data_; }
+
+    // These dataFirst() routines refer to the element in the
+    // array which falls first in memory.
+
+    int                               dataFirstOffset() const
+    {
+        int pos = 0;
+
+        // Used to use tinyvector expressions:
+        // return data_ + dot(storage_.base()
+        //     + (1 - storage_.ascendingFlag()) * (length_ - 1), stride_);
+
+        for (int i=0; i < N_rank; ++i)
+           pos += (storage_.base(i) + (1-storage_.isRankStoredAscending(i)) *
+              (length_(i)-1)) * stride_(i);
+
+        return pos;
+    }
+    
+    const T_numtype* restrict     dataFirst() const
+    {
+        return data_ + dataFirstOffset();
+    }
+
+    T_numtype* restrict           dataFirst()
+    {
+        return data_ + dataFirstOffset();
+    }
+
+    int                               depth() const
+    { return length_[2]; }
+
+    int                               dimensions() const
+    { return N_rank; }
+
+    RectDomain<N_rank>                domain() const
+    {
+        return RectDomain<N_rank>(lbound(), ubound());
+    }
+
+    void dumpStructureInformation(ostream& os = cout) const;
+
+    iterator                          end()
+    {
+        return iterator();
+    }
+
+    const_iterator                    end() const
+    {
+        return const_iterator();
+    }
+
+    int                               extent(int rank) const
+    { return length_[rank]; }
+
+    const TinyVector<int,N_rank>&     extent() const
+    { return length_; }
+
+    template<typename P_numtype2>
+    Array<P_numtype2,N_rank>          extractComponent(P_numtype2, int compNum,
+                                          int numComponents) const;
+
+    void                              free() 
+    {
+        changeToNullBlock();
+        length_ = 0;
+    }
+ 
+    bool isMajorRank(int rank) const { return storage_.ordering(rank) == 0; }
+    bool isMinorRank(int rank) const { return storage_.ordering(rank) != 0; }
+    bool isRankStoredAscending(int rank) const {
+        return storage_.isRankStoredAscending(rank);
+    }
+
+    bool isStorageContiguous() const;
+
+    int                    lbound(int rank) const { return base(rank); }
+    TinyVector<int,N_rank> lbound()         const { return base(); }
+
+    int                            length(int rank) const { return length_[rank]; }
+    const TinyVector<int, N_rank>& length()         const { return length_; }
+
+    void makeUnique();
+
+    int numElements() const { return product(length_); }
+
+    // NEEDS_WORK -- Expose the numReferences() method
+    // MemoryBlockReference<T_numtype>::numReferences;
+
+    // The storage_.ordering_ array is a list of dimensions from
+    // the most minor (stride 1) to major dimension.  Generally,
+    // ordering(0) will return the dimension which has the smallest
+    // stride, and ordering(N_rank-1) will return the dimension with
+    // the largest stride.
+    int                               ordering(int storageRankIndex) const
+    { return storage_.ordering(storageRankIndex); }
+
+    const TinyVector<int, N_rank>&    ordering() const
+    { return storage_.ordering(); }
+
+    void                              transposeSelf(int r0, int r1, int r2=0, 
+        int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int 
+        r9=0, int r10=0);
+    T_array                           transpose(int r0, int r1, int r2=0,
+        int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int
+        r9=0, int r10=0);
+
+    int                               rank() const
+    { return N_rank; }
+
+    void                              reference(const T_array&);
+
+    // Added by Derrick Bass
+    T_array                           reindex(const TinyVector<int,N_rank>&);
+    void                              reindexSelf(const 
+                                                TinyVector<int,N_rank>&);
+
+    void                              resize(int extent);
+    void                              resize(int extent1, int extent2);
+    void                              resize(int extent1, int extent2,
+                                        int extent3);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6, int extent7);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6, int extent7, int extent8);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6, int extent7, int extent8,
+                                        int extent9);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6, int extent7, int extent8,
+                                        int extent9, int extent10);
+    void                              resize(int extent1, int extent2,
+                                        int extent3, int extent4, int extent5,
+                                        int extent6, int extent7, int extent8,
+                                        int extent9, int extent10, 
+                                        int extent11);
+
+
+    void                              resize(Range r1);
+    void                              resize(Range r1, Range r2);
+    void                              resize(Range r1, Range r2, Range r3);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6,
+                                        Range r7);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6,
+                                        Range r7, Range r8);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6,
+                                        Range r7, Range r8, Range r9);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6,
+                                        Range r7, Range r8, Range r9, 
+                                        Range r10);
+    void                              resize(Range r1, Range r2, Range r3,
+                                        Range r4, Range r5, Range r6,
+                                        Range r7, Range r8, Range r9, 
+                                        Range r10, Range r11);
+
+    void                              resize(const TinyVector<int,N_rank>&);
+ 
+
+    void                              resizeAndPreserve(const TinyVector<int,
+                                                                   N_rank>&);
+    void                              resizeAndPreserve(int extent);
+    void                              resizeAndPreserve(int extent1, 
+                                        int extent2);
+    void                              resizeAndPreserve(int extent1, 
+                                        int extent2, int extent3);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6, int extent7);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6, int extent7,
+                                        int extent8);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6, int extent7,
+                                        int extent8, int extent9);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6, int extent7,
+                                        int extent8, int extent9, 
+                                        int extent10);
+    void                              resizeAndPreserve(int extent1,
+                                        int extent2, int extent3, int extent4,
+                                        int extent5, int extent6, int extent7,
+                                        int extent8, int extent9, int extent10,
+                                        int extent11);
+
+    // NEEDS_WORK -- resizeAndPreserve(Range,...)
+    // NEEDS_WORK -- resizeAndPreserve(const Domain<N_rank>&);
+
+    T_array                           reverse(int rank);
+    void                              reverseSelf(int rank);
+
+    int                               rows() const
+    { return length_[0]; }
+    
+    void                              setStorage(GeneralArrayStorage<N_rank>);
+    
+    void                              slice(int rank, Range r);
+
+    const TinyVector<int, N_rank>&    shape() const
+    { return length_; }
+
+    int                               size() const
+    { return numElements(); }
+
+    const TinyVector<int, N_rank>&    stride() const
+    { return stride_; }
+
+    int                               stride(int rank) const
+    { return stride_[rank]; }
+
+    int                               ubound(int rank) const
+    { return base(rank) + length_(rank) - 1; }
+
+    TinyVector<int, N_rank>           ubound() const
+    { 
+        TinyVector<int, N_rank> ub;
+        for (int i=0; i < N_rank; ++i)
+          ub(i) = base(i) + extent(i) - 1;
+        // WAS: ub = base() + extent() - 1;
+        return ub;
+    }
+
+    int                               zeroOffset() const
+    { return zeroOffset_; }
+
+    //////////////////////////////////////////////
+    // Debugging routines
+    //////////////////////////////////////////////
+
+    bool isInRangeForDim(int i, int d) const {
+        return i >= base(d) && (i - base(d)) < length_[d];
+    }
+
+    bool isInRange(int i0) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0];
+    }
+
+    bool isInRange(int i0, int i1) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1];
+    }
+
+    bool isInRange(int i0, int i1, int i2) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5]
+            && i6 >= base(6) && (i6 - base(6)) < length_[6];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4,
+        int i5, int i6, int i7) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5]
+            && i6 >= base(6) && (i6 - base(6)) < length_[6]
+            && i7 >= base(7) && (i7 - base(7)) < length_[7];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4,
+        int i5, int i6, int i7, int i8) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5]
+            && i6 >= base(6) && (i6 - base(6)) < length_[6]
+            && i7 >= base(7) && (i7 - base(7)) < length_[7]
+            && i8 >= base(8) && (i8 - base(8)) < length_[8];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4,
+        int i5, int i6, int i7, int i8, int i9) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5]
+            && i6 >= base(6) && (i6 - base(6)) < length_[6]
+            && i7 >= base(7) && (i7 - base(7)) < length_[7]
+            && i8 >= base(8) && (i8 - base(8)) < length_[8]
+            && i9 >= base(9) && (i9 - base(9)) < length_[9];
+    }
+
+    bool isInRange(int i0, int i1, int i2, int i3, int i4,
+        int i5, int i6, int i7, int i8, int i9, int i10) const {
+        return i0 >= base(0) && (i0 - base(0)) < length_[0]
+            && i1 >= base(1) && (i1 - base(1)) < length_[1]
+            && i2 >= base(2) && (i2 - base(2)) < length_[2]
+            && i3 >= base(3) && (i3 - base(3)) < length_[3]
+            && i4 >= base(4) && (i4 - base(4)) < length_[4]
+            && i5 >= base(5) && (i5 - base(5)) < length_[5]
+            && i6 >= base(6) && (i6 - base(6)) < length_[6]
+            && i7 >= base(7) && (i7 - base(7)) < length_[7]
+            && i8 >= base(8) && (i8 - base(8)) < length_[8]
+            && i9 >= base(9) && (i9 - base(9)) < length_[9]
+            && i10 >= base(10) && (i10 - base(10)) < length_[10];
+    }
+
+    bool isInRange(const T_index& index) const {
+        for (int i=0; i < N_rank; ++i)
+            if (index[i] < base(i) || (index[i] - base(i)) >= length_[i])
+                return false;
+
+        return true;
+    }
+
+    bool assertInRange(const T_index& BZ_DEBUG_PARAM(index)) const {
+        BZPRECHECK(isInRange(index), "Array index out of range: " << index
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0)) const {
+        BZPRECHECK(isInRange(i0), "Array index out of range: " << i0
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const {
+        BZPRECHECK(isInRange(i0,i1), "Array index out of range: (" 
+            << i0 << ", " << i1 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2), "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3), "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3),
+        int BZ_DEBUG_PARAM(i4)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4), "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3 
+            << ", " << i4 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5), "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6), 
+            "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ", " << i6 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6),
+        int BZ_DEBUG_PARAM(i7)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7),
+            "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
+        int BZ_DEBUG_PARAM(i8)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8),
+            "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7 
+            << ", " << i8 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
+        int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9),
+            "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
+            << ", " << i8 << ", " << i9 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
+        int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
+        int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
+        int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9),
+        int BZ_DEBUG_PARAM(i10)) const
+    {
+        BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10),
+            "Array index out of range: ("
+            << i0 << ", " << i1 << ", " << i2 << ", " << i3
+            << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
+            << ", " << i8 << ", " << i9 << ", " << i10 << ")"
+            << endl << "Lower bounds: " << storage_.base() << endl
+            <<         "Length:       " << length_ << endl);
+        return true;
+    }
+
+    //////////////////////////////////////////////
+    // Subscripting operators
+    //////////////////////////////////////////////
+
+    template<int N_rank2>
+    const T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index) const
+    {
+        assertInRange(index);
+        return data_[dot(index, stride_)];
+    }
+
+    template<int N_rank2>
+    T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index) 
+    {
+        assertInRange(index);
+        return data_[dot(index, stride_)];
+    }
+
+    const T_numtype& restrict operator()(TinyVector<int,1> index) const
+    {
+        assertInRange(index[0]);
+        return data_[index[0] * stride_[0]];
+    }
+
+    T_numtype& operator()(TinyVector<int,1> index)
+    {
+        assertInRange(index[0]);
+        return data_[index[0] * stride_[0]];
+    }
+
+    const T_numtype& restrict operator()(TinyVector<int,2> index) const
+    {
+        assertInRange(index[0], index[1]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]];
+    }
+
+    T_numtype& operator()(TinyVector<int,2> index)
+    {
+        assertInRange(index[0], index[1]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]];
+    }
+
+    const T_numtype& restrict operator()(TinyVector<int,3> index) const
+    {
+        assertInRange(index[0], index[1], index[2]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2]];
+    }
+
+    T_numtype& operator()(TinyVector<int,3> index)
+    {
+        assertInRange(index[0], index[1], index[2]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,4>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,4>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,5>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,5>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,6>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,6>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,7>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,7>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,8>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,8>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,9>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,9>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,10>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8], index[9]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8] + index[9] * stride_[9]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,10>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8], index[9]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8] + index[9] * stride_[9]];
+    }
+
+    const T_numtype& restrict operator()(const TinyVector<int,11>& index) const
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8], index[9],
+            index[10]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8] + index[9] * stride_[9]
+            + index[10] * stride_[10]];
+    }
+
+    T_numtype& operator()(const TinyVector<int,11>& index)
+    {
+        assertInRange(index[0], index[1], index[2], index[3],
+            index[4], index[5], index[6], index[7], index[8], index[9],
+            index[10]);
+        return data_[index[0] * stride_[0] + index[1] * stride_[1]
+            + index[2] * stride_[2] + index[3] * stride_[3]
+            + index[4] * stride_[4] + index[5] * stride_[5]
+            + index[6] * stride_[6] + index[7] * stride_[7]
+            + index[8] * stride_[8] + index[9] * stride_[9]
+            + index[10] * stride_[10]];
+    }
+
+    const T_numtype& restrict operator()(int i0) const
+    { 
+        assertInRange(i0);
+        return data_[i0 * stride_[0]]; 
+    }
+
+    T_numtype& restrict operator()(int i0) 
+    {
+        assertInRange(i0);
+        return data_[i0 * stride_[0]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1) const
+    { 
+        assertInRange(i0, i1);
+        return data_[i0 * stride_[0] + i1 * stride_[1]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1)
+    {
+        assertInRange(i0, i1);
+        return data_[i0 * stride_[0] + i1 * stride_[1]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2) const
+    {
+        assertInRange(i0, i1, i2);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2) 
+    {
+        assertInRange(i0, i1, i2);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3) const
+    {
+        assertInRange(i0, i1, i2, i3);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3)
+    {
+        assertInRange(i0, i1, i2, i3);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4) const
+    {
+        assertInRange(i0, i1, i2, i3, i4);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4)
+    {
+        assertInRange(i0, i1, i2, i3, i4);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8, int i9) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8] + i9 * stride_[9]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8, int i9)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8] + i9 * stride_[9]];
+    }
+
+    const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8, int i9, int i10) const
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, 
+            i9, i10);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
+    }
+
+    T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
+        int i4, int i5, int i6, int i7, int i8, int i9, int i10)
+    {
+        assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, 
+            i9, i10);
+        return data_[i0 * stride_[0] + i1 * stride_[1]
+            + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
+            + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
+            + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
+    }
+
+    /*
+     * Slicing to produce subarrays.  If the number of Range arguments is
+     * fewer than N_rank, then missing arguments are treated like Range::all().
+     */
+
+    T_array& noConst() const
+    { return const_cast<T_array&>(*this); }
+
+    T_array operator()(const RectDomain<N_rank>& subdomain) const
+    {
+        return T_array(noConst(), subdomain);
+    }
+
+    /* Operator added by Julian Cummings */
+    T_array operator()(const StridedDomain<N_rank>& subdomain) const
+    {
+        return T_array(noConst(), subdomain);
+    }
+
+    T_array operator()(Range r0) const
+    {
+        return T_array(noConst(), r0);
+    }
+
+    T_array operator()(Range r0, Range r1) const
+    {
+        return T_array(noConst(), r0, r1);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2) const
+    {
+        return T_array(noConst(), r0, r1, r2);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5, Range r6) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5, Range r6, Range r7) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5, Range r6, Range r7, Range r8) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5, Range r6, Range r7, Range r8, Range r9) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
+    }
+
+    T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
+        Range r5, Range r6, Range r7, Range r8, Range r9, Range r10) const
+    {
+        return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
+    }
+
+    // Allow any mixture of Range, int and Vector<int> objects as
+    // operands for operator():   A(Range(3,7), 5, Range(2,4))
+
+    /*
+     * These versions of operator() allow any combination of int
+     * and Range operands to be used.  Each int operand reduces
+     * the rank of the resulting array by one.  
+     *
+     * e.g.  Array<int,4> A(20,20,20,20);
+     *       Array<int,2> B = A(Range(5,15), 3, 5, Range(8,9));
+     *
+     * SliceInfo is a helper class defined in <blitz/arrayslice.h>.
+     * It counts the number of Range vs. int arguments and does some
+     * other helpful things.
+     *
+     * Once partial specialization becomes widely implemented, these
+     * operators may be expanded to accept Vector<int> arguments
+     * and produce ArrayPick<T,N> objects.
+     *
+     * This operator() is not provided with a single argument because
+     * the appropriate cases exist above.
+     */
+
+#ifdef BZ_HAVE_PARTIAL_ORDERING
+
+    template<typename T1, typename T2>
+    typename SliceInfo<T_numtype,T1,T2>::T_slice
+    operator()(T1 r1, T2 r2) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2>::T_slice slice;
+        return slice(noConst(), r1, r2, nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3>
+    typename SliceInfo<T_numtype,T1,T2,T3>::T_slice 
+    operator()(T1 r1, T2 r2, T3 r3) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, nilArraySection(),
+            nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, nilArraySection(), nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+        typename T7>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, nilArraySection(), nilArraySection(),
+            nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+        typename T7, typename T8>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8,
+            nilArraySection(), nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+        typename T7, typename T8, typename T9>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, nilArraySection(), nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+        typename T7, typename T8, typename T9, typename T10>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, nilArraySection());
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+        typename T7, typename T8, typename T9, typename T10, typename T11>
+    typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice
+    operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10, T11 r11) const
+    {
+        typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice slice;
+        return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11);
+    }
+
+#endif // BZ_HAVE_PARTIAL_ORDERING
+
+    /*
+     * These versions of operator() are provided to support tensor-style
+     * array notation, e.g.
+     *
+     * Array<float, 2> A, B;
+     * firstIndex i;
+     * secondIndex j;
+     * thirdIndex k;
+     * Array<float, 3> C = A(i,j) * B(j,k);
+     */
+
+    template<int N0>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0> >
+    operator()(IndexPlaceholder<N0>) const
+    { 
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0> >
+            (noConst());
+    }
+
+    template<int N0, int N1>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1> >(noConst());
+    } 
+
+    template<int N0, int N1, int N2>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3, N4> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, 
+        IndexPlaceholder<N4>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3, 
+        N4, N5> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5, int N6>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
+        N4, N5, N6> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>, IndexPlaceholder<N6>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5, N6> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
+        int N7>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
+        N4, N5, N6, N7> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>, IndexPlaceholder<N6>, 
+        IndexPlaceholder<N7>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5, N6, N7> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
+        int N7, int N8>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
+        N4, N5, N6, N7, N8> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
+        IndexPlaceholder<N8>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5, N6, N7, N8> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
+        int N7, int N8, int N9>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
+        N4, N5, N6, N7, N8, N9> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
+        IndexPlaceholder<N8>, IndexPlaceholder<N9>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5, N6, N7, N8, N9> >(noConst());
+    }
+
+    template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
+        int N7, int N8, int N9, int N10>
+    _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
+        N4, N5, N6, N7, N8, N9, N10> >
+    operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
+        IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
+        IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
+        IndexPlaceholder<N8>, IndexPlaceholder<N9>, 
+        IndexPlaceholder<N10>) const
+    {
+        return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
+            N1, N2, N3, N4, N5, N6, N7, N8, N9, N10> >(noConst());
+    }
+
+    //////////////////////////////////////////////
+    // Support for multicomponent arrays
+    //////////////////////////////////////////////
+
+    /*
+     * See <blitz/array/multi.h> for an explanation of the traits class
+     * multicomponent_traits.
+     */
+
+    Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
+    operator[](const unsigned component) {
+        typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
+
+        return extractComponent(T_compType(),component,
+                                multicomponent_traits<T_numtype>::numComponents);
+    }
+
+    const Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
+    operator[](const unsigned component) const {
+        typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
+
+        return extractComponent(T_compType(),component,
+                                multicomponent_traits<T_numtype>::numComponents);
+    }
+
+    Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
+    operator[](const int component) {
+        return operator[](static_cast<unsigned>(component));
+    }
+
+    const Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
+    operator[](const int component) const {
+        return operator[](static_cast<unsigned>(component));
+    }
+
+    //////////////////////////////////////////////
+    // Indirection
+    //////////////////////////////////////////////
+ 
+    template<typename T_indexContainer>
+    IndirectArray<T_array, T_indexContainer>
+    operator[](const T_indexContainer& index)
+    {
+        return IndirectArray<T_array, T_indexContainer>(*this,
+            const_cast<T_indexContainer&>(index));
+    }
+ 
+    //////////////////////////////////////////////
+    // Assignment Operators
+    //////////////////////////////////////////////
+
+    // Scalar operand
+    // NEEDS_WORK : need a precondition check on
+    // isStorageContiguous when operator, is used.
+    ListInitializationSwitch<T_array,T_numtype*> operator=(T_numtype x)
+    {
+        return ListInitializationSwitch<T_array,T_numtype*>(*this, x);
+    }
+
+    T_array& initialize(T_numtype);
+
+    // Was:
+    // T_array& operator=(T_numtype);
+
+#ifdef BZ_NEW_EXPRESSION_TEMPLATES
+    template<typename T_expr>
+    T_array& operator=(const ETBase<T_expr>&);
+    T_array& operator=(const Array<T_numtype,N_rank>&);
+
+    template<typename T> T_array& operator+=(const T&);
+    template<typename T> T_array& operator-=(const T&);
+    template<typename T> T_array& operator*=(const T&);
+    template<typename T> T_array& operator/=(const T&);
+    template<typename T> T_array& operator%=(const T&);
+    template<typename T> T_array& operator^=(const T&);
+    template<typename T> T_array& operator&=(const T&);
+    template<typename T> T_array& operator|=(const T&);
+    template<typename T> T_array& operator>>=(const T&);
+    template<typename T> T_array& operator<<=(const T&);
+
+#else
+    T_array& operator+=(T_numtype);
+    T_array& operator-=(T_numtype);
+    T_array& operator*=(T_numtype);
+    T_array& operator/=(T_numtype);
+    T_array& operator%=(T_numtype);
+    T_array& operator^=(T_numtype);
+    T_array& operator&=(T_numtype);
+    T_array& operator|=(T_numtype);
+    T_array& operator>>=(T_numtype);
+    T_array& operator<<=(T_numtype);
+
+    // Array operands
+    T_array& operator=(const Array<T_numtype,N_rank>&);
+
+    template<typename P_numtype2> 
+    T_array& operator=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator+=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator-=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator*=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator/=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator%=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator^=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator&=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator|=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator>>=(const Array<P_numtype2,N_rank>&);
+    template<typename P_numtype2>
+    T_array& operator<<=(const Array<P_numtype2,N_rank>&);
+
+    // Array expression operands
+    template<typename T_expr>
+    inline T_array& operator=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator+=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator-=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator*=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator/=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator%=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator^=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator&=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator|=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator>>=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+    template<typename T_expr>
+    inline T_array& operator<<=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
+
+    // NEEDS_WORK -- Index placeholder operand
+
+    // NEEDS_WORK -- Random operand
+#endif
+
+public:
+    // Undocumented implementation routines
+
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluate(T_expr expr, T_update);
+
+#ifdef BZ_HAVE_STD
+#ifdef BZ_ARRAY_SPACE_FILLING_TRAVERSAL
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithFastTraversal(
+        const TraversalOrder<N_rank - 1>& order, 
+        T_expr expr, T_update);
+#endif // BZ_ARRAY_SPACE_FILLING_TRAVERSAL
+#endif
+
+#ifdef BZ_ARRAY_2D_STENCIL_TILING
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithTiled2DTraversal(
+        T_expr expr, T_update);
+#endif
+
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithIndexTraversal1(
+        T_expr expr, T_update);
+
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithIndexTraversalN(
+        T_expr expr, T_update);
+
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithStackTraversal1(
+        T_expr expr, T_update);
+
+    template<typename T_expr, typename T_update>
+    inline T_array& evaluateWithStackTraversalN(
+        T_expr expr, T_update);
+
+
+    T_numtype* restrict getInitializationIterator() { return dataFirst(); }
+
+    bool canCollapse(int outerRank, int innerRank) const { 
+#ifdef BZ_DEBUG_TRAVERSE
+        BZ_DEBUG_MESSAGE("stride(" << innerRank << ")=" << stride(innerRank)
+          << ", extent()=" << extent(innerRank) << ", stride(outerRank)="
+          << stride(outerRank));
+#endif
+        return (stride(innerRank) * extent(innerRank) == stride(outerRank)); 
+    }
+
+protected:
+    //////////////////////////////////////////////
+    // Implementation routines
+    //////////////////////////////////////////////
+
+    _bz_inline2 void computeStrides();
+    _bz_inline2 void setupStorage(int rank);
+    void constructSubarray(Array<T_numtype, N_rank>& array, 
+        const RectDomain<N_rank>&);
+    void constructSubarray(Array<T_numtype, N_rank>& array,
+        const StridedDomain<N_rank>&);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0, Range r1);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5, Range r6);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
+        Range r7);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
+        Range r7, Range r8);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
+        Range r7, Range r8, Range r9);
+    void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
+        Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
+        Range r7, Range r8, Range r9, Range r10);
+
+    void calculateZeroOffset();
+
+    template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, 
+        typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
+    void constructSlice(Array<T_numtype, N_rank2>& array, R0 r0, R1 r1, R2 r2, 
+        R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10);
+
+    template<int N_rank2>
+    void slice(int& setRank, Range r, Array<T_numtype,N_rank2>& array,
+        TinyVector<int,N_rank2>& rankMap, int sourceRank);
+
+    template<int N_rank2>
+    void slice(int& setRank, int i, Array<T_numtype,N_rank2>& array,
+        TinyVector<int,N_rank2>& rankMap, int sourceRank);
+
+    template<int N_rank2>
+    void slice(int&, nilArraySection, Array<T_numtype,N_rank2>&,
+        TinyVector<int,N_rank2>&, int)
+    { }
+
+    void doTranspose(int destRank, int sourceRank, T_array& array);
+
+protected:
+    //////////////////////////////////////////////
+    // Data members
+    //////////////////////////////////////////////
+
+    // NB: adding new data members may require changes to ctors, reference()
+
+    /*
+     * For a description of the storage_ members, see the comments for class 
+     * GeneralArrayStorage<N_rank> above.
+     *
+     * length_[] contains the extent of each rank.  E.g. a 10x20x30 array
+     *           would have length_ = { 10, 20, 30}.
+     * stride_[] contains the stride to move to the next element along each
+     *           rank.
+     * zeroOffset_ is the distance from the first element in the array 
+     *           to the point (0,0,...,0).  If base_ is zero and all ranks are 
+     *           stored ascending, then zeroOffset_ is zero.  This value
+     *           is needed because to speed up indexing, the data_ member
+     *           (inherited from MemoryBlockReference) always refers to
+     *           (0,0,...,0).
+     */
+    GeneralArrayStorage<N_rank> storage_;
+    TinyVector<int, N_rank> length_;
+    TinyVector<int, N_rank> stride_;
+    int zeroOffset_;
+};
+
+/*
+ * Rank numbers start with zero, which may be confusing to users coming
+ * from Fortran.  To make code more readable, the following constants
+ * may help.  Example: instead of
+ * 
+ * int firstRankExtent = A.extent(0);
+ *
+ * One can write:
+ *
+ * int firstRankExtent = A.extent(firstRank);
+ */
+
+const int firstRank    = 0;
+const int secondRank   = 1;
+const int thirdRank    = 2;
+const int fourthRank   = 3;
+const int fifthRank    = 4;
+const int sixthRank    = 5;
+const int seventhRank  = 6;
+const int eighthRank   = 7;
+const int ninthRank    = 8;
+const int tenthRank    = 9;
+const int eleventhRank = 10;
+
+const int firstDim    = 0;
+const int secondDim   = 1;
+const int thirdDim    = 2;
+const int fourthDim   = 3;
+const int fifthDim    = 4;
+const int sixthDim    = 5;
+const int seventhDim  = 6;
+const int eighthDim   = 7;
+const int ninthDim    = 8;
+const int tenthDim    = 9;
+const int eleventhDim = 10;
+
+/*
+ * Global Functions
+ */
+
+template<typename T_numtype>
+ostream& operator<<(ostream&, const Array<T_numtype,1>&);
+
+template<typename T_numtype>
+ostream& operator<<(ostream&, const Array<T_numtype,2>&);
+
+template<typename T_numtype, int N_rank>
+ostream& operator<<(ostream&, const Array<T_numtype,N_rank>&);
+
+template<typename T_numtype, int N_rank>
+istream& operator>>(istream& is, Array<T_numtype,N_rank>& x);
+
+template <typename P_numtype,int N_rank>
+void swap(Array<P_numtype,N_rank>& a,Array<P_numtype,N_rank>& b) {
+    Array<P_numtype,N_rank> c(a);
+    a.reference(b);
+    b.reference(c);
+}
+
+template <typename P_expr>
+void find(Array<TinyVector<int,P_expr::rank>,1>& indices,
+          const _bz_ArrayExpr<P_expr>& expr) {
+    find(indices,
+         static_cast< Array<typename P_expr::T_numtype,P_expr::rank> >(expr));
+}
+
+template <typename P_numtype, int N_rank>
+void find(Array<TinyVector<int,N_rank>,1>& indices,
+          const Array<P_numtype,N_rank>& exprVals) {
+    indices.resize(exprVals.size());
+    typename Array<P_numtype,N_rank>::const_iterator it, end = exprVals.end();
+    int j=0; 
+    for (it = exprVals.begin(); it != end; ++it)
+        if (*it) 
+            indices(j++) = it.position();
+    if (j) 
+        indices.resizeAndPreserve(j);
+    else 
+        indices.free();
+    return;
+}
+
+
+BZ_NAMESPACE_END
+
+/*
+ * Include implementations of the member functions and some additional
+ * global functions.
+ */
+
+#include <blitz/array/iter.h>       // Array iterators
+#include <blitz/array/fastiter.h>   // Fast Array iterators (for et)
+#include <blitz/array/expr.h>       // Array expression objects
+#include <blitz/array/methods.cc>   // Member functions
+#include <blitz/array/eval.cc>      // Array expression evaluation
+#include <blitz/array/ops.cc>       // Assignment operators
+#include <blitz/array/io.cc>        // Output formatting
+#include <blitz/array/et.h>         // Expression templates
+#include <blitz/array/reduce.h>     // Array reduction expression templates
+#include <blitz/array/interlace.cc> // Allocation of interlaced arrays
+#include <blitz/array/resize.cc>    // Array resize, resizeAndPreserve
+#include <blitz/array/slicing.cc>   // Slicing and subarrays
+#include <blitz/array/cycle.cc>     // Cycling arrays
+#include <blitz/array/complex.cc>   // Special support for complex arrays
+#include <blitz/array/zip.h>        // Zipping multicomponent types
+#include <blitz/array/where.h>      // where(X,Y,Z)
+#include <blitz/array/indirect.h>   // Indirection
+#include <blitz/array/stencils.h>   // Stencil objects
+
+#endif // BZ_ARRAY_H
Index: /XMLIO_V2/external/include/blitz/array-old.h
===================================================================
--- /XMLIO_V2/external/include/blitz/array-old.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/array-old.h	(revision 73)
@@ -0,0 +1,56 @@
+/***************************************************************************
+ * blitz/array-old.h  Maximal include version of Array<P_numtype, N_rank>
+ *                    Note: see <blitz/array-impl.h> for the class def.
+ *
+ * $Id: array-old.h,v 1.2 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_ARRAY_OLD_H
+#define BZ_ARRAY_OLD_H
+
+/*
+ * <blitz/array.h> used to include most of the Blitz++ library
+ * functionality, totally ~ 120000 lines of source code.  This
+ * made for extremely slow compile times; processing #include <blitz/array.h>
+ * took gcc about 25 seconds on a 500 MHz pentium box.
+ *
+ * Much of this compile time was due to the old vector expression templates
+ * implementation.  Since this is not really needed for the Array<T,N>
+ * class, the headers were redesigned so that:
+ *
+ * #include <blitz/array-old.h>   is the old-style include, pulls in most
+ *                                of Blitz++ including vector e.t. 
+ * #include <blitz/array.h>       pulls in much less of the library, and
+ *                                in particular excludes the vector e.t. code
+ *
+ * With <blitz/array-old.h>, one gets TinyVector expressions automatically.
+ * With <blitz/array.h>, one must now also include <blitz/tinyvec-et.h> 
+ * to get TinyVector expressions.
+ *
+ * The implementation of Array<T,N> has been moved to <blitz/array-impl.h>.
+ */
+
+#include <blitz/tinyvec-et.h>
+#include <blitz/array-impl.h>
+
+#endif // BZ_ARRAY_OLD_H
+
Index: /XMLIO_V2/external/include/blitz/array.h
===================================================================
--- /XMLIO_V2/external/include/blitz/array.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/array.h	(revision 73)
@@ -0,0 +1,35 @@
+/***************************************************************************
+ * blitz/array.h    Minimal include version of Array<T,N>
+ *
+ * $Id: array.h,v 1.6 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2000 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_ARRAY_ONLY_H
+#define BZ_ARRAY_ONLY_H
+
+// See comments in <blitz/array-old.h> for an explanation of the new
+// headers arrangement.
+
+#include <blitz/array-impl.h>
+
+#endif  // BZ_ARRAY_ONLY_H
+
Index: /XMLIO_V2/external/include/blitz/bench.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/bench.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/bench.cc	(revision 73)
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_BENCH_CC
+#define BZ_BENCH_CC
+
+#ifndef BZ_BENCH_H
+ #error <blitz/bench.cc> must be included via <blitz/bench.h>
+#endif
+
+#ifdef BZ_HAVE_STD
+ #include <fstream>
+#else
+ #include <fstream.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_parameter>
+Benchmark<P_parameter>::Benchmark(unsigned numImplementations)
+{
+    state_ = uninitialized;
+    numImplementations_ = numImplementations;
+    numStoredImplementations_ = 0;
+    implementations_ = new BenchmarkImplementation<P_parameter>* [numImplementations_];
+    rates_.resize(numImplementations, numParameterSettings());
+    Mflops_.resize(numImplementations, numParameterSettings());
+}
+
+template<typename P_parameter>
+Benchmark<P_parameter>::~Benchmark()
+{
+    delete [] implementations_;
+}
+
+template<typename P_parameter>
+void Benchmark<P_parameter>::addImplementation(
+    BenchmarkImplementation<P_parameter> * implementation)
+{
+    BZPRECONDITION(state_ == uninitialized);
+    BZPRECONDITION(numStoredImplementations_ < numImplementations_);
+
+    implementations_[numStoredImplementations_++] = implementation;
+
+    if (numStoredImplementations_ == numImplementations_)
+        state_ = initialized;
+}
+
+template<typename P_parameter>
+void Benchmark<P_parameter>::run(ostream& log)
+{
+    BZPRECONDITION(state_ == initialized);
+    state_ = running;
+
+    Timer t;
+
+    for (unsigned j=0; j < numImplementations_; ++j)
+    {
+        for (unsigned i=0; i < numParameterSettings(); ++i)
+        {
+            log  << setw(20) << implementations_[j]->implementationName()
+                 << " " << setw(8) << getParameterSetting(i) << "  ";
+            log.flush();
+
+            implementations_[j]->initialize(getParameterSetting(i));
+            implementations_[j]->tickle();
+
+            unsigned long iterations = getIterationSetting(i);
+
+            t.start();
+            implementations_[j]->run(iterations);
+            t.stop();
+            double tm = t.elapsedSeconds();
+
+            t.start();
+            implementations_[j]->runOverhead(iterations);
+            t.stop();
+            double tmOverhead = t.elapsedSeconds();
+
+            rates_(j,i) = iterations / (tm - tmOverhead);
+            Mflops_(j,i) = rates_(j,i) 
+                * implementations_[j]->flopsPerIteration() / 1.0e+6;
+
+            log << setw(10) << (rates_(j,i)/1.0e+6) << " Mops/s ";
+
+            if (implementations_[j]->flopsPerIteration() != 0)
+            {
+                log << "[" << setw(7) << Mflops_(j,i) << " Mflops]";
+            }
+
+            log << endl;
+            log.flush();
+
+            implementations_[j]->done();
+        }
+    }
+
+    state_ = done;
+}
+
+template<typename P_parameter>
+double Benchmark<P_parameter>::getMflops(unsigned implementation, 
+    unsigned setting) const
+{
+    BZPRECONDITION(state_ == done);
+    BZPRECONDITION(implementation < numImplementations_);
+    BZPRECONDITION(setting < numParameterSettings());
+
+    return Mflops_(implementation, setting);
+}
+
+template<typename P_parameter>
+double Benchmark<P_parameter>::getRate(unsigned implementation,  
+    unsigned setting) const
+{
+    BZPRECONDITION(state_ == done);
+    BZPRECONDITION(implementation < numImplementations_);
+    BZPRECONDITION(setting < numParameterSettings());
+
+    return rates_(implementation, setting);
+}
+
+template<typename P_parameter>
+void Benchmark<P_parameter>::saveMatlabGraph(const char* filename) const
+{
+    BZPRECONDITION(state_ == done);
+
+    ofstream ofs(filename);
+     
+    assert(ofs.good());
+
+    ofs << "% This matlab file generated automatically by class Benchmark"
+        << endl << "% of the Blitz++ class library." << endl << endl;
+
+    ofs.setf(ios::scientific);
+
+    ofs << "parm = [ ";
+    int i;
+    for (i=0; i < numParameterSettings(); ++i)
+        ofs << setprecision(12) << double(getParameterSetting(i)) << " ";
+    ofs << "]; " << endl << endl;
+
+    ofs << "Mf = [ ";
+    for (i=0; i < numParameterSettings(); ++i)
+    {
+        for (int j=0; j < numImplementations_; ++j)
+        {
+            ofs << setprecision(12) << getMflops(j,i) << " ";
+        }
+        if (i != numParameterSettings()-1)
+            ofs << ";" << endl;
+    }
+    ofs << "] ;" << endl << endl;
+
+    ofs << "semilogx(parm,Mf), title('" << description() << "'), " << endl
+        << "    xlabel('" << parameterDescription() << "'), "
+        << "ylabel('Mflops')" << endl
+        << "legend(";
+    
+    for (int j=0; j < numImplementations_; ++j)
+    {
+        ofs << "'" << implementations_[j]->implementationName()
+            << "'";
+        if (j != numImplementations_ - 1)
+            ofs << ", ";
+    } 
+
+    ofs << ")" << endl;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_BENCH_CC
Index: /XMLIO_V2/external/include/blitz/bench.h
===================================================================
--- /XMLIO_V2/external/include/blitz/bench.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/bench.h	(revision 73)
@@ -0,0 +1,135 @@
+/***************************************************************************
+ * blitz/bench.h      Benchmark classes
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_BENCH_H
+#define BZ_BENCH_H
+
+#ifndef BZ_MATRIX_H
+ #include <blitz/matrix.h>
+#endif
+
+#ifndef BZ_TIMER_H
+ #include <blitz/timer.h>
+#endif
+
+#include <math.h>
+
+BZ_NAMESPACE(blitz)
+
+// Forward declaration
+template<typename P_parameter = unsigned>
+class BenchmarkImplementation;
+
+
+// Declaration of class Benchmark<T>
+// The template parameter T is the parameter type which is varied in
+// the benchmark.  Typically T will be an unsigned, and will represent
+// the length of a vector, size of an array, etc.
+
+template<typename P_parameter = unsigned>
+class Benchmark {
+
+public:
+    typedef P_parameter T_parameter;
+
+    Benchmark(unsigned numImplementations);
+
+    ~Benchmark();
+
+    void addImplementation(BenchmarkImplementation<T_parameter>* 
+        implementation);
+
+    void run(ostream& log = cout);
+
+    double getMflops(unsigned implementation, unsigned setting) const;
+
+    double getRate(unsigned implementation, unsigned setting) const;
+
+    void saveMatlabGraph(const char* filename) const;
+
+public:
+    // Virtual functions
+
+    virtual const char* description() const
+    { return ""; }
+
+    virtual const char* parameterDescription() const
+    { return "Vector length"; }
+
+    virtual unsigned numParameterSettings() const
+    { return 19; }
+
+    virtual T_parameter getParameterSetting(unsigned i) const
+    { return ::pow(10.0, (i+1)/4.0); }
+
+    virtual long getIterationSetting(unsigned i) const
+    { return 1000000L / getParameterSetting(i); }
+
+private:
+    Benchmark(const Benchmark<P_parameter>&) { }
+    void operator=(const Benchmark<P_parameter>&) { }
+
+    enum { uninitialized, initialized, running, done } state_;
+
+    unsigned numImplementations_;
+    unsigned numStoredImplementations_;
+
+    BenchmarkImplementation<T_parameter>** implementations_;
+
+    Matrix<double,RowMajor> rates_;       // Iterations per second array
+    Matrix<double,RowMajor> Mflops_;
+};
+
+template<typename P_parameter>
+class BenchmarkImplementation {
+
+public:
+    typedef P_parameter T_parameter;
+
+    virtual void initialize(P_parameter parameter) { }
+
+    virtual void done() { }
+
+    virtual const char* implementationName() const
+    { return ""; }
+
+    virtual void run(long iterations) = 0;
+
+    virtual void runOverhead(long iterations) 
+    { 
+        for (long i=0; i < iterations; ++i)
+        {
+        }
+    };
+
+    virtual void tickle() { }
+
+    virtual long flopsPerIteration() const
+    { return 0; }
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/bench.cc>  
+
+#endif // BZ_BENCH_H
Index: /XMLIO_V2/external/include/blitz/benchext.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/benchext.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/benchext.cc	(revision 73)
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_BENCHEXT_CC
+#define BZ_BENCHEXT_CC
+
+#ifndef BZ_BENCHEXT_H
+ #error <blitz/benchext.cc> must be included via <blitz/benchext.h>
+#endif
+
+#include <blitz/vector-et.h>
+
+#ifdef BZ_HAVE_STD
+ #include <fstream>
+#else
+ #include <fstream.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_parameter>
+BenchmarkExt<P_parameter>::BenchmarkExt(const char* name, 
+    int numImplementations)
+{
+    BZPRECONDITION(numImplementations > 0);
+
+    description_ = name;
+    numImplementations_ = numImplementations;
+
+    implementationDescriptions_.resize(numImplementations);
+    parameterDescription_ = "Vector length";
+    rateDescription_ = "Mflops/s";
+
+    // Set up default parameters and iterations
+    setNumParameters(19);
+
+    // NEEDS_WORK: once pow(X,Y) is supported, can just say
+    // parameters_ = pow(10.0, Range(1,20)/4.0);
+
+    for (unsigned i=0; i < numParameters_; ++i)
+        parameters_[i] = (P_parameter)::pow(10.0, (i+1)/4.0);
+
+    iterations_ = 5.0e+5 / parameters_;
+    flopsPerIteration_ = parameters_;
+
+    // Set up initial state
+    state_ = initializing;
+    implementationNumber_ = 0;
+}
+
+template<typename P_parameter>
+BenchmarkExt<P_parameter>::~BenchmarkExt()
+{
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setNumParameters(int numParameters)
+{
+    //BZPRECONDITION(state_ == initializing);
+
+    numParameters_ = numParameters;
+
+    parameters_.resize(numParameters_);
+    iterations_.resize(numParameters_);
+    flopsPerIteration_.resize(numParameters_);
+
+    // Set up timer and Mflops array
+    times_.resize(numImplementations_, numParameters_);
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setParameterVector(Vector<P_parameter> parms)
+{
+    BZPRECONDITION(state_ == initializing);
+    BZPRECONDITION(parms.length() == parameters_.length());
+
+    // NEEDS_WORK: should use operator=(), once that problem
+    // gets sorted out.
+    // parameters_ = parms;
+    for (int i=0; i < parameters_.length(); ++i)
+        parameters_[i] = parms(i);
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setParameterDescription(const char* string)
+{
+    parameterDescription_ = string;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setIterations(Vector<long> iters)
+{
+    BZPRECONDITION(state_ == initializing);
+
+    // NEEDS_WORK: should use operator=(), once that problem
+    // gets sorted out.
+    // iterations_ = iters;
+
+    for (int i=0; i < iterations_.length(); ++i)
+        iterations_[i] = iters(i);
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setFlopsPerIteration(Vector<double> 
+    flopsPerIteration)
+{
+    BZPRECONDITION(flopsPerIteration_.length() == flopsPerIteration.length());
+
+    // NEEDS_WORK: should use operator=(), once that problem
+    // gets sorted out.
+    // flopsPerIteration_ = flopsPerIteration;
+
+    for (int i=0; i < flopsPerIteration_.length(); ++i)
+        flopsPerIteration_[i] = flopsPerIteration[i];
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::setRateDescription(const char* string)
+{
+    rateDescription_ = string;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::beginBenchmarking()
+{
+    BZPRECONDITION(state_ == initializing);
+    state_ = benchmarking;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::beginImplementation(const char* description)
+{
+    BZPRECONDITION(implementationNumber_ < numImplementations_);
+    BZPRECONDITION(state_ == benchmarking);
+
+    implementationDescriptions_[implementationNumber_] = description;
+
+    state_ = benchmarkingImplementation;
+    parameterNumber_ = 0;
+}
+
+template<typename P_parameter>
+bool BenchmarkExt<P_parameter>::doneImplementationBenchmark() const
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    return parameterNumber_ == numParameters_;
+}
+
+template<typename P_parameter>
+P_parameter BenchmarkExt<P_parameter>::getParameter() const
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    BZPRECONDITION(parameterNumber_ < numParameters_);
+
+    return parameters_[parameterNumber_];
+}
+
+template<typename P_parameter>
+long BenchmarkExt<P_parameter>::getIterations() const
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    BZPRECONDITION(parameterNumber_ < numParameters_);
+
+    return iterations_[parameterNumber_];
+}
+
+template<typename P_parameter>
+inline void BenchmarkExt<P_parameter>::start()
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    BZPRECONDITION(parameterNumber_ < numParameters_);
+    state_ = running;
+    timer_.start();
+}
+
+template<typename P_parameter>
+inline void BenchmarkExt<P_parameter>::stop()
+{
+    timer_.stop();
+    BZPRECONDITION(state_ == running);
+    state_ = benchmarkingImplementation;
+    
+    times_(implementationNumber_, parameterNumber_) = timer_.elapsedSeconds();
+
+    ++parameterNumber_;
+}
+
+template<typename P_parameter>
+inline void BenchmarkExt<P_parameter>::startOverhead()
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    BZPRECONDITION(parameterNumber_ > 0);
+    BZPRECONDITION(parameterNumber_ <= numParameters_);
+    state_ = runningOverhead;
+    overheadTimer_.start();
+}
+
+template<typename P_parameter>
+inline void BenchmarkExt<P_parameter>::stopOverhead()
+{
+    BZPRECONDITION(state_ == runningOverhead);
+    overheadTimer_.stop();
+    times_(implementationNumber_, parameterNumber_-1) -= 
+        overheadTimer_.elapsedSeconds();
+
+    state_ = benchmarkingImplementation;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::endImplementation()
+{
+    BZPRECONDITION(state_ == benchmarkingImplementation);
+    BZPRECONDITION(parameterNumber_ == numParameters_);
+
+    ++implementationNumber_;
+
+    state_ = benchmarking;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::endBenchmarking()
+{
+    BZPRECONDITION(state_ == benchmarking);
+    BZPRECONDITION(implementationNumber_ == numImplementations_);
+    
+    state_ = done;
+}
+
+template<typename P_parameter>
+double BenchmarkExt<P_parameter>::getMflops(unsigned implementation,
+    unsigned parameterNum) const
+{
+    BZPRECONDITION(state_ == done);
+    BZPRECONDITION(implementation < numImplementations_);
+    BZPRECONDITION(parameterNum < numParameters_);
+    return iterations_(parameterNum) * flopsPerIteration_(parameterNum)
+        / times_(implementation, parameterNum) / 1.0e+6;
+}
+
+template<typename P_parameter>
+void BenchmarkExt<P_parameter>::saveMatlabGraph(const char* filename, const char* graphType) const
+{
+    BZPRECONDITION(state_ == done);
+
+    ofstream ofs(filename);
+     
+    assert(ofs.good());
+
+    ofs << "% This matlab file generated automatically by class Benchmark"
+        << endl << "% of the Blitz++ class library." << endl << endl;
+
+    ofs.setf(ios::scientific);
+
+    // This will be a lot simpler once Matlab-style output formatting
+    // of vectors & matrices is finished.
+
+    // ofs << "parm = " << parameters_ << ";" << endl << endl;
+
+    ofs << "parm = [ ";
+    unsigned i;
+    for (i=0; i < numParameters_; ++i)
+        ofs << setprecision(12) << double(parameters_[i]) << " ";
+    ofs << "]; " << endl << endl;
+
+    ofs << "Mf = [ ";
+    for (i=0; i < numParameters_; ++i)
+    {
+        for (unsigned j=0; j < numImplementations_; ++j)
+        {
+            ofs << setprecision(12) << getMflops(j,i) << " ";
+        }
+        if (i != numParameters_ - 1)
+            ofs << ";" << endl;
+    }
+    ofs << "] ;" << endl << endl;
+
+    ofs << graphType << "(parm,Mf), title('" << description_ << "'), " << endl
+        << "    xlabel('" << parameterDescription_ << "'), "
+        << "ylabel('" << rateDescription_ << "')" << endl
+        << "legend(";
+    
+    for (unsigned j=0; j < numImplementations_; ++j)
+    {
+        ofs << "'" << implementationDescriptions_(j) << "'";
+        if (j != numImplementations_ - 1)
+            ofs << ", ";
+    } 
+
+    ofs << ")" << endl;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_BENCHEXT_CC
Index: /XMLIO_V2/external/include/blitz/benchext.h
===================================================================
--- /XMLIO_V2/external/include/blitz/benchext.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/benchext.h	(revision 73)
@@ -0,0 +1,121 @@
+/***************************************************************************
+ * blitz/benchext.h      BenchmarkExt classes (Benchmarks with external
+ *                       control)
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_BENCHEXT_H
+#define BZ_BENCHEXT_H
+
+#ifndef BZ_MATRIX_H
+ #include <blitz/matrix.h>
+#endif
+
+#ifndef BZ_TIMER_H
+ #include <blitz/timer.h>
+#endif
+
+#include <math.h>
+
+// NEEDS_WORK: replace use of const char* with <string>, once standard
+// library is widely supported.
+
+BZ_NAMESPACE(blitz)
+
+// Declaration of class BenchmarkExt<T>
+// The template parameter T is the parameter type which is varied in
+// the benchmark.  Typically T will be an unsigned, and will represent
+// the length of a vector, size of an array, etc.
+
+template<typename P_parameter = unsigned>
+class BenchmarkExt {
+
+public:
+    typedef P_parameter T_parameter;
+
+    BenchmarkExt(const char* description, int numImplementations);
+
+    ~BenchmarkExt();
+
+    void setNumParameters(int numParameters);
+    void setParameterVector(Vector<T_parameter> parms);
+    void setParameterDescription(const char* string);
+    void setIterations(Vector<long> iters);
+    void setFlopsPerIteration(Vector<double> flopsPerIteration);
+    void setRateDescription(const char* string);
+
+    void beginBenchmarking();
+
+    void beginImplementation(const char* description);
+
+    bool doneImplementationBenchmark() const;
+
+    T_parameter getParameter() const;
+    long        getIterations() const;
+
+    inline void start();
+    inline void stop();
+
+    void startOverhead();
+    void stopOverhead();
+
+    void endImplementation();
+
+    void endBenchmarking();
+ 
+    double getMflops(unsigned implementation, unsigned parameterNum) const;
+
+    void saveMatlabGraph(const char* filename, const char* graphType="semilogx") const;
+
+protected:
+    BenchmarkExt(const BenchmarkExt<P_parameter>&) { }
+    void operator=(const BenchmarkExt<P_parameter>&) { }
+
+    enum { initializing, benchmarking, benchmarkingImplementation, 
+       running, runningOverhead, done } state_;
+
+    unsigned numImplementations_;
+    unsigned implementationNumber_;
+
+    const char* description_;
+    Vector<const char*> implementationDescriptions_;
+
+    Matrix<double,RowMajor> times_;       // Elapsed time
+
+    Vector<T_parameter> parameters_;
+    Vector<long> iterations_;
+    Vector<double> flopsPerIteration_;
+
+    Timer timer_;
+    Timer overheadTimer_;
+
+    const char* parameterDescription_;
+    const char* rateDescription_;
+
+    unsigned numParameters_;
+    unsigned parameterNumber_;
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/benchext.cc>  
+
+#endif // BZ_BENCHEXT_H
Index: /XMLIO_V2/external/include/blitz/blitz.h
===================================================================
--- /XMLIO_V2/external/include/blitz/blitz.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/blitz.h	(revision 73)
@@ -0,0 +1,127 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/blitz.h      Includes all the important header files
+ *
+ * $Id: blitz.h,v 1.14 2005/05/18 23:35:55 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org    
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_BLITZ_H
+#define BZ_BLITZ_H
+
+/*
+ * These symbols allow use of the IEEE and System V math libraries
+ * (libm.a and libmsaa.a) on some platforms.
+ */
+
+#ifdef BZ_ENABLE_XOPEN_SOURCE
+ #ifndef _ALL_SOURCE
+  #define _ALL_SOURCE
+ #endif
+ #ifndef _XOPEN_SOURCE
+  #define _XOPEN_SOURCE
+ #endif
+ #ifndef _XOPEN_SOURCE_EXTENDED
+  #define _XOPEN_SOURCE_EXTENDED 1
+ #endif
+#endif
+
+#include <blitz/compiler.h>          // Compiler-specific directives
+#include <blitz/tuning.h>            // Performance tuning
+#include <blitz/tau.h>               // Profiling
+
+#include <string>
+#include <stdio.h>                   // sprintf, etc.
+
+#ifdef BZ_HAVE_STD
+  #include <iostream>
+  #include <iomanip>
+#else
+  #include <iostream.h>
+  #include <iomanip.h>
+#endif
+
+#ifdef BZ_MATH_FN_IN_NAMESPACE_STD 
+  #include <cmath>
+#else
+  #include <math.h>
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+  #include <complex>
+#endif
+
+#define BZ_THROW                     // Needed in <blitz/numinquire.h>
+
+BZ_NAMESPACE(blitz)
+
+#ifdef BZ_HAVE_STD
+ BZ_USING_NAMESPACE(std)
+#endif
+
+#ifdef BZ_GENERATE_GLOBAL_INSTANCES
+ #define _bz_global
+ #define BZ_GLOBAL_INIT(X)   =X
+#else
+ #define _bz_global extern
+ #define BZ_GLOBAL_INIT(X) 
+#endif
+
+BZ_NAMESPACE_END
+
+/*
+ * Thread safety issues.
+ * Compiling with -pthread under gcc, or -mt under solaris,
+ * should automatically turn on BZ_THREADSAFE.
+ */
+#ifdef _REENTRANT
+ #ifndef BZ_THREADSAFE
+  #define BZ_THREADSAFE
+ #endif
+#endif
+
+/*
+ * Which mutex implementation should be used for synchronizing
+ * reference counts.   Currently only one option -- pthreads.
+ */
+#ifdef BZ_THREADSAFE
+#define BZ_THREADSAFE_USE_PTHREADS
+#endif
+
+#ifdef BZ_THREADSAFE_USE_PTHREADS
+ #include <pthread.h>
+
+ #define BZ_MUTEX_DECLARE(name)   mutable pthread_mutex_t name;
+ #define BZ_MUTEX_INIT(name)      pthread_mutex_init(&name,NULL);
+ #define BZ_MUTEX_LOCK(name)      pthread_mutex_lock(&name);
+ #define BZ_MUTEX_UNLOCK(name)    pthread_mutex_unlock(&name);
+ #define BZ_MUTEX_DESTROY(name)   pthread_mutex_destroy(&name);
+#else
+ #define BZ_MUTEX_DECLARE(name)
+ #define BZ_MUTEX_INIT(name)
+ #define BZ_MUTEX_LOCK(name)
+ #define BZ_MUTEX_UNLOCK(name)
+ #define BZ_MUTEX_DESTROY(name)
+#endif
+
+#include <blitz/bzdebug.h>           // Debugging macros
+
+#endif // BZ_BLITZ_H
Index: /XMLIO_V2/external/include/blitz/bzconfig.h
===================================================================
--- /XMLIO_V2/external/include/blitz/bzconfig.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/bzconfig.h	(revision 73)
@@ -0,0 +1,63 @@
+/* Select the compiler-specific config.h header file */
+#ifndef BZCONFIG_H
+#define BZCONFIG_H
+
+#if defined(__APPLE)
+/* IBM xlc compiler for Darwin */
+#include <blitz/apple/bzconfig.h>
+
+#elif defined(__ICC)
+/* Intel icc compiler */
+#include <blitz/intel/bzconfig.h>
+
+#elif defined(_MSC_VER)
+/* Microsoft VS.NET compiler */
+#include <blitz/ms/bzconfig.h>
+
+#elif defined(__IBM)
+/* IBM xlC compiler */
+#include <blitz/ibm/bzconfig.h>
+
+#elif defined(__DECCXX)
+/* Compaq cxx compiler */
+#include <blitz/compaq/bzconfig.h>
+
+#elif defined(__HP_aCC)
+/* HP aCC compiler */
+#include <blitz/hp/bzconfig.h>
+
+#elif defined(_SGI_COMPILER_VERSION)
+/* SGI CC compiler */
+#include <blitz/sgi/bzconfig.h>
+
+#elif defined(__SUNPRO_CC)
+/* SunPRO CC compiler */
+#include <blitz/sun/bzconfig.h>
+
+#elif defined(__GNUC__)
+/* GNU gcc compiler */
+#include <blitz/gnu/bzconfig.h>
+
+#elif defined(__PGI)
+/* PGI pgCC compiler */
+#include <blitz/pgi/bzconfig.h>
+
+#elif defined(__KCC)
+/* KAI KCC compiler */
+#include <blitz/kai/bzconfig.h>
+
+#elif defined(__FUJITSU)
+/* Fujitsu FCC compiler */
+#include <blitz/fujitsu/bzconfig.h>
+
+#elif defined(__PATHSCALE)
+/* Pathscale pathCC compiler */
+#include <blitz/pathscale/bzconfig.h>
+
+/* Add other compilers here */
+
+#else
+#error Unknown compiler
+#endif
+
+#endif /* BZCONFIG_H */
Index: /XMLIO_V2/external/include/blitz/bzdebug.h
===================================================================
--- /XMLIO_V2/external/include/blitz/bzdebug.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/bzdebug.h	(revision 73)
@@ -0,0 +1,227 @@
+/***************************************************************************
+ * blitz/bzdebug.h      Debugging macros
+ *
+ * $Id: bzdebug.h,v 1.6 2004/10/06 21:58:33 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_DEBUG_H
+#define BZ_DEBUG_H
+
+#ifdef BZ_HAVE_STDLIB_H
+ #include <stdlib.h>
+#endif
+#include <assert.h>
+
+#ifdef BZ_HAVE_RTTI
+ #include <typeinfo>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * These globals are used by the Blitz++ testsuite.  The _bz_global 
+ * modifier ensures that they will reside in libblitz.a, but appear
+ * "extern" elsewhere.
+ */
+
+_bz_global bool assertFailMode     BZ_GLOBAL_INIT(false);
+_bz_global int  assertFailCount    BZ_GLOBAL_INIT(0);
+_bz_global int  assertSuccessCount BZ_GLOBAL_INIT(0);
+
+
+#if defined(BZ_TESTSUITE)
+  /*
+   * In testsuite mode, these routines allow a test suite to check
+   * that precondition checking is being done properly.  A typical
+   * use looks like this:
+   *
+   * beginCheckAssert();
+   *   // Some operation which should cause an assert to fail
+   * endCheckAssert();
+   *
+   * The routine beginCheckAssert() sets a flag which results in
+   * failed asserts being silently tallied.  If no asserts have
+   * failed by the time endCheckAssert() is invoked, the program
+   * halts and issues an error code.
+   *
+   * In normal operation (i.e. when beginCheckAssert() has not
+   * been called), failed preconditions will cause the program
+   * to halt and issue an error code.   -- TV 980226
+   */
+
+  inline void checkAssert(bool condition, const char* where=0, 
+    int line=0)
+  {
+    if (assertFailMode == true)
+    {
+      if (condition == true)
+        ++assertSuccessCount;
+      else
+        ++assertFailCount;
+    }
+    else {
+      if (!condition)
+      {
+        cerr << "Unexpected assert failure!" << endl;
+        if (where)
+            cerr << where << ":" << line << endl;
+        cerr.flush();
+        assert(0);
+      }
+    }
+  }
+
+  inline void beginCheckAssert()
+  {
+    assertFailMode = true;
+    assertSuccessCount = 0;
+    assertFailCount = 0;
+  }
+
+  inline void endCheckAssert()
+  {
+    assert(assertFailMode == true);
+    assertFailMode = false;
+    if (assertFailCount == 0)
+    {
+      cerr << "Assert check failed!" << endl;
+      assert(0);
+    }
+  }
+
+    #define BZASSERT(X)        checkAssert(X, __FILE__, __LINE__)
+    #define BZPRECONDITION(X)  checkAssert(X, __FILE__, __LINE__)
+    #define BZPOSTCONDITION(X) checkAssert(X, __FILE__, __LINE__)
+    #define BZSTATECHECK(X,Y)  checkAssert(X == Y, __FILE__, __LINE__)
+    #define BZPRECHECK(X,Y)                                    \
+        {                                                      \
+            if ((assertFailMode == false) && (!(X)))       \
+                cerr << Y << endl;                             \
+            checkAssert(X, __FILE__, __LINE__);                \
+        }
+
+    #define BZ_DEBUG_MESSAGE(X)                                          \
+        {                                                                \
+            if (assertFailMode == false)                             \
+            {                                                            \
+                cout << __FILE__ << ":" << __LINE__ << " " << X << endl; \
+            }                                                            \
+        }
+
+    #define BZ_DEBUG_PARAM(X) X
+    #define BZ_PRE_FAIL        checkAssert(0)
+    #define BZ_ASM_DEBUG_MARKER
+
+#elif defined(BZ_DEBUG)
+
+    #define BZASSERT(X)        assert(X)
+    #define BZPRECONDITION(X)  assert(X)
+    #define BZPOSTCONDITION(X) assert(X)
+    #define BZSTATECHECK(X,Y)  assert(X == Y)
+    #define BZPRECHECK(X,Y)                                                 \
+        { if (!(X))                                                         \
+          { cerr << "[Blitz++] Precondition failure: Module " << __FILE__   \
+               << " line " << __LINE__ << endl                              \
+               << Y << endl;                                                \
+            cerr.flush();                                                   \
+            assert(0);                                                      \
+          }                                                                 \
+        }
+
+    #define BZ_DEBUG_MESSAGE(X) \
+        { cout << __FILE__ << ":" << __LINE__ << " " << X << endl; }
+
+    #define BZ_DEBUG_PARAM(X) X
+    #define BZ_PRE_FAIL      assert(0)
+
+// This routine doesn't exist anywhere; it's used to mark a
+// position of interest in assembler (.s) files
+    void _bz_debug_marker();
+    #define BZ_ASM_DEBUG_MARKER   _bz_debug_marker();
+
+#else   // !BZ_TESTSUITE && !BZ_DEBUG
+
+    #define BZASSERT(X)
+    #define BZPRECONDITION(X)
+    #define BZPOSTCONDITION(X)
+    #define BZSTATECHECK(X,Y)
+    #define BZPRECHECK(X,Y)
+    #define BZ_DEBUG_MESSAGE(X)
+    #define BZ_DEBUG_PARAM(X)
+    #define BZ_PRE_FAIL
+    #define BZ_ASM_DEBUG_MARKER
+
+#endif  // !BZ_TESTSUITE && !BZ_DEBUG
+
+#define BZ_NOT_IMPLEMENTED()   { cerr << "[Blitz++] Not implemented: module " \
+    << __FILE__ << " line " << __LINE__ << endl;                \
+    exit(1); }
+
+#ifdef BZ_HAVE_RTTI
+#define BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(X)  typeid(X).name()
+#else
+
+template<typename T>
+class _bz_stringLiteralForNumericType {
+public:
+    static const char* string()
+    { return "unknown"; }
+};
+
+#define BZ_DECL_SLFNT(X,Y) \
+ template<>                 \
+ class _bz_stringLiteralForNumericType< X > {  \
+ public:                                       \
+     static const char* string()               \
+     { return Y; }                             \
+ }
+
+#ifdef BZ_HAVE_BOOL
+BZ_DECL_SLFNT(bool, "bool");
+#endif
+
+BZ_DECL_SLFNT(char, "char");
+BZ_DECL_SLFNT(unsigned char, "unsigned char");
+BZ_DECL_SLFNT(short int, "short int");
+BZ_DECL_SLFNT(short unsigned int, "short unsigned int");
+BZ_DECL_SLFNT(int, "int");
+BZ_DECL_SLFNT(unsigned int, "unsigned int");
+BZ_DECL_SLFNT(long, "long");
+BZ_DECL_SLFNT(unsigned long, "unsigned long");
+BZ_DECL_SLFNT(float, "float");
+BZ_DECL_SLFNT(double, "double");
+BZ_DECL_SLFNT(long double, "long double");
+
+#ifdef BZ_HAVE_COMPLEX
+BZ_DECL_SLFNT(complex<float>, "complex<float>");
+BZ_DECL_SLFNT(complex<double>, "complex<double>");
+BZ_DECL_SLFNT(complex<long double>, "complex<long double>");
+#endif
+
+#define BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(X) \
+    _bz_stringLiteralForNumericType<X>::string()
+
+#endif // !BZ_HAVE_RTTI
+
+BZ_NAMESPACE_END
+
+#endif // BZ_DEBUG_H
Index: /XMLIO_V2/external/include/blitz/compiler.h
===================================================================
--- /XMLIO_V2/external/include/blitz/compiler.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/compiler.h	(revision 73)
@@ -0,0 +1,152 @@
+/***************************************************************************
+ * blitz/compiler.h      Compiler specific directives and kludges
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_COMPILER_H
+#define BZ_COMPILER_H
+
+// The file <blitz/bzconfig.h> is used to select a compiler-specific
+// config.h file that is generated automatically by configure.
+
+#include <blitz/bzconfig.h>
+
+/*
+ * Define some kludges.
+ */
+
+#ifndef BZ_HAVE_TEMPLATES
+    #error  In <blitz/config.h>: A working template implementation is required by Blitz++ (you may need to rerun the compiler/bzconfig script)
+#endif
+
+#ifndef BZ_HAVE_MEMBER_TEMPLATES
+  #error  In <blitz/config.h>: Your compiler does not support member templates.  (you may need to rerun the compiler/bzconfig script)
+#endif
+
+#ifndef BZ_HAVE_FULL_SPECIALIZATION_SYNTAX
+  #error In <blitz/config.h>: Your compiler does not support template<> full specialization syntax.  You may need to rerun the compiler/bzconfig script.
+#endif
+
+#ifndef BZ_HAVE_PARTIAL_ORDERING
+  #error In <blitz/config.h>: Your compiler does not support partial ordering (you may need to rerun the compiler/bzconfig script)
+#endif
+
+#ifndef BZ_HAVE_PARTIAL_SPECIALIZATION
+  #error In <blitz/config.h>: Your compiler does not support partial specialization (you may need to rerun the compiler/bzconfig script)
+#endif
+
+#ifdef BZ_HAVE_NAMESPACES
+    #define BZ_NAMESPACE(X)        namespace X {
+    #define BZ_NAMESPACE_END       }
+    #define BZ_USING_NAMESPACE(X)  using namespace X;
+#else
+    #define BZ_NAMESPACE(X)
+    #define BZ_NAMESPACE_END
+    #define BZ_USING_NAMESPACE(X)
+#endif
+
+#ifdef BZ_HAVE_TEMPLATE_QUALIFIED_RETURN_TYPE
+  #define BZ_USE_NUMTRAIT
+#endif
+
+#ifdef BZ_HAVE_DEFAULT_TEMPLATE_PARAMETERS
+    #define BZ_TEMPLATE_DEFAULT(X)   = X
+#else
+    #define BZ_TEMPLATE_DEFAULT
+#endif
+
+#ifndef BZ_HAVE_EXPLICIT
+    #define explicit   
+#endif
+
+#ifdef BZ_HAVE_TYPENAME
+    #define _bz_typename     typename
+#else
+    #define _bz_typename
+#endif
+
+#ifndef BZ_HAVE_MUTABLE
+    #define mutable
+#endif
+
+#ifdef BZ_DISABLE_RESTRICT
+ #undef BZ_HAVE_NCEG_RESTRICT
+#endif
+
+#ifndef BZ_HAVE_NCEG_RESTRICT
+    #if defined(BZ_HAVE_NCEG_RESTRICT_EGCS)
+        #define restrict     __restrict__
+    #else
+        #define restrict
+    #endif
+#endif
+
+#if !defined(BZ_HAVE_BOOL) && !defined(BZ_NO_BOOL_KLUDGE)
+    #define bool    int
+    #define true    1
+    #define false   0
+#endif
+
+#ifdef BZ_HAVE_ENUM_COMPUTATIONS_WITH_CAST
+    #define BZ_ENUM_CAST(X)   (int)X
+#elif defined(BZ_HAVE_ENUM_COMPUTATIONS)
+    #define BZ_ENUM_CAST(X)   X
+#else
+    #error In <blitz/config.h>: Your compiler does not support enum computations.  You may have to rerun compiler/bzconfig.
+#endif
+
+#if defined(BZ_MATH_FN_IN_NAMESPACE_STD)
+  #define BZ_MATHFN_SCOPE(x) std::x
+#elif defined(BZ_HAVE_NAMESPACES)
+  #define BZ_MATHFN_SCOPE(x) ::x
+#else
+  #define BZ_MATHFN_SCOPE(x) x
+#endif
+
+#if defined(BZ_HAVE_COMPLEX_MATH_IN_NAMESPACE_STD)
+  #define BZ_CMATHFN_SCOPE(x) std::x
+#elif defined(BZ_HAVE_NAMESPACES)
+  #define BZ_CMATHFN_SCOPE(x) ::x
+#else
+  #define BZ_CMATHFN_SCOPE(x) x
+#endif
+
+#if defined(BZ_HAVE_NAMESPACES)
+  #define BZ_IEEEMATHFN_SCOPE(x) ::x
+#else
+  #define BZ_IEEEMATHFN_SCOPE(x) x
+#endif
+
+#if defined(BZ_HAVE_NAMESPACES)
+  #define BZ_BLITZ_SCOPE(x) blitz::x
+#else
+  #define BZ_BLITZ_SCOPE(x) ::x
+#endif
+
+#if defined(BZ_HAVE_NAMESPACES) && defined(BZ_HAVE_STD)
+  #define BZ_STD_SCOPE(x) std::x
+#else
+  #define BZ_STD_SCOPE(x) ::x
+#endif
+
+#endif // BZ_COMPILER_H
+
Index: /XMLIO_V2/external/include/blitz/etbase.h
===================================================================
--- /XMLIO_V2/external/include/blitz/etbase.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/etbase.h	(revision 73)
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/etbase.h    Declaration of the ETBase<T> class
+ *
+ * $Id: etbase.h,v 1.5 2003/12/30 23:03:29 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_ETBASE_H
+#define BZ_ETBASE_H
+
+BZ_NAMESPACE(blitz)
+
+template<typename T>
+class ETBase { 
+public:
+    ETBase() 
+    { }
+
+    ETBase(const ETBase<T>&)
+    { }
+    
+    T& unwrap() { return static_cast<T&>(*this); }
+    
+    const T& unwrap() const { return static_cast<const T&>(*this); }
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_ETBASE_H
+
Index: /XMLIO_V2/external/include/blitz/extremum.h
===================================================================
--- /XMLIO_V2/external/include/blitz/extremum.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/extremum.h	(revision 73)
@@ -0,0 +1,73 @@
+/***************************************************************************
+ * blitz/extremum.h      Declaration of the Extremum<T_numtype, T_index> class
+ *
+ * $Id: extremum.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_EXTREMUM_H
+#define BZ_EXTREMUM_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// The Extremum class is used for returning extreme values and their
+// locations in a numeric container.  It's a simple 2-tuple, with the
+// first element being the extreme value, and the send its location.
+// An object of type Extremum can be automatically converted to
+// the numeric type via operator T_numtype().
+template<typename P_numtype, typename P_index>
+class Extremum {
+public:
+    typedef P_numtype T_numtype;
+    typedef P_index   T_index;
+
+    Extremum(T_numtype value, T_index index)
+        : value_(value), index_(index)
+    { }
+
+    T_numtype value() const
+    { return value_; }
+
+    T_index index() const
+    { return index_; }
+
+    void setValue(T_numtype value)
+    { value_ = value; }
+
+    void setIndex(T_index index)
+    { index_ = index; }
+
+    operator T_numtype() const
+    { return value_; }
+
+protected:
+    T_numtype value_;
+    T_index index_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_EXTREMUM_H
+
Index: /XMLIO_V2/external/include/blitz/funcs.h
===================================================================
--- /XMLIO_V2/external/include/blitz/funcs.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/funcs.h	(revision 73)
@@ -0,0 +1,682 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/funcs.h            Function objects for math functions
+ *
+ * $Id: funcs.h,v 1.7 2005/10/08 01:22:55 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ *************************************************************************/
+
+#ifndef BZ_FUNCS_H
+#define BZ_FUNCS_H
+
+#include <blitz/blitz.h>
+#include <blitz/promote.h>
+#include <blitz/prettyprint.h>
+
+BZ_NAMESPACE(blitz)
+    
+/* Helper functions */
+    
+template <typename T>
+inline T blitz_sqr(T x)
+{ return x*x; }
+
+template <typename T>
+inline T blitz_cube(T x)
+{ return x*x*x; }
+
+template <typename T>
+inline T blitz_pow4(T x)
+{ return x*x*x*x; }
+
+template <typename T>
+inline T blitz_pow5(T x)
+{ return x*x*x*x*x; }
+
+template <typename T>
+inline T blitz_pow6(T x)
+{ return x*x*x*x*x*x; }
+
+template <typename T>
+inline T blitz_pow7(T x)
+{ return x*x*x*x*x*x*x; }
+
+template <typename T>
+inline T blitz_pow8(T x)
+{ return x*x*x*x*x*x*x*x; }
+
+
+/* Unary functions that return same type as argument */
+    
+#define BZ_DEFINE_UNARY_FUNC(name,fun)                         \
+template<typename T_numtype1>                                  \
+struct name {                                                  \
+    typedef T_numtype1 T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return fun(a); }                                         \
+							       \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};
+
+BZ_DEFINE_UNARY_FUNC(Fn_acos,BZ_MATHFN_SCOPE(acos))
+BZ_DEFINE_UNARY_FUNC(Fn_asin,BZ_MATHFN_SCOPE(asin))
+BZ_DEFINE_UNARY_FUNC(Fn_atan,BZ_MATHFN_SCOPE(atan))
+BZ_DEFINE_UNARY_FUNC(Fn_ceil,BZ_MATHFN_SCOPE(ceil))
+BZ_DEFINE_UNARY_FUNC(Fn_cos,BZ_MATHFN_SCOPE(cos))
+BZ_DEFINE_UNARY_FUNC(Fn_cosh,BZ_MATHFN_SCOPE(cosh))
+BZ_DEFINE_UNARY_FUNC(Fn_exp,BZ_MATHFN_SCOPE(exp))
+BZ_DEFINE_UNARY_FUNC(Fn_fabs,BZ_MATHFN_SCOPE(fabs))
+BZ_DEFINE_UNARY_FUNC(Fn_floor,BZ_MATHFN_SCOPE(floor))
+BZ_DEFINE_UNARY_FUNC(Fn_log,BZ_MATHFN_SCOPE(log))
+BZ_DEFINE_UNARY_FUNC(Fn_log10,BZ_MATHFN_SCOPE(log10))
+BZ_DEFINE_UNARY_FUNC(Fn_sin,BZ_MATHFN_SCOPE(sin))
+BZ_DEFINE_UNARY_FUNC(Fn_sinh,BZ_MATHFN_SCOPE(sinh))
+BZ_DEFINE_UNARY_FUNC(Fn_sqrt,BZ_MATHFN_SCOPE(sqrt))
+BZ_DEFINE_UNARY_FUNC(Fn_tan,BZ_MATHFN_SCOPE(tan))
+BZ_DEFINE_UNARY_FUNC(Fn_tanh,BZ_MATHFN_SCOPE(tanh))
+
+#ifdef BZ_HAVE_IEEE_MATH
+BZ_DEFINE_UNARY_FUNC(Fn_acosh,BZ_IEEEMATHFN_SCOPE(acosh))
+BZ_DEFINE_UNARY_FUNC(Fn_asinh,BZ_IEEEMATHFN_SCOPE(asinh))
+BZ_DEFINE_UNARY_FUNC(Fn_atanh,BZ_IEEEMATHFN_SCOPE(atanh))
+BZ_DEFINE_UNARY_FUNC(Fn_cbrt,BZ_IEEEMATHFN_SCOPE(cbrt))
+BZ_DEFINE_UNARY_FUNC(Fn_erf,BZ_IEEEMATHFN_SCOPE(erf))
+BZ_DEFINE_UNARY_FUNC(Fn_erfc,BZ_IEEEMATHFN_SCOPE(erfc))
+BZ_DEFINE_UNARY_FUNC(Fn_expm1,BZ_IEEEMATHFN_SCOPE(expm1))
+BZ_DEFINE_UNARY_FUNC(Fn_j0,BZ_IEEEMATHFN_SCOPE(j0))
+BZ_DEFINE_UNARY_FUNC(Fn_j1,BZ_IEEEMATHFN_SCOPE(j1))
+BZ_DEFINE_UNARY_FUNC(Fn_lgamma,BZ_IEEEMATHFN_SCOPE(lgamma))
+BZ_DEFINE_UNARY_FUNC(Fn_logb,BZ_IEEEMATHFN_SCOPE(logb))
+BZ_DEFINE_UNARY_FUNC(Fn_log1p,BZ_IEEEMATHFN_SCOPE(log1p))
+BZ_DEFINE_UNARY_FUNC(Fn_rint,BZ_IEEEMATHFN_SCOPE(rint))
+BZ_DEFINE_UNARY_FUNC(Fn_y0,BZ_IEEEMATHFN_SCOPE(y0))
+BZ_DEFINE_UNARY_FUNC(Fn_y1,BZ_IEEEMATHFN_SCOPE(y1))
+#endif
+    
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+BZ_DEFINE_UNARY_FUNC(Fn__class,BZ_IEEEMATHFN_SCOPE(_class))
+BZ_DEFINE_UNARY_FUNC(Fn_nearest,BZ_IEEEMATHFN_SCOPE(nearest))
+BZ_DEFINE_UNARY_FUNC(Fn_rsqrt,BZ_IEEEMATHFN_SCOPE(rsqrt))
+#endif
+    
+BZ_DEFINE_UNARY_FUNC(Fn_sqr,BZ_BLITZ_SCOPE(blitz_sqr))
+BZ_DEFINE_UNARY_FUNC(Fn_cube,BZ_BLITZ_SCOPE(blitz_cube))
+BZ_DEFINE_UNARY_FUNC(Fn_pow4,BZ_BLITZ_SCOPE(blitz_pow4))
+BZ_DEFINE_UNARY_FUNC(Fn_pow5,BZ_BLITZ_SCOPE(blitz_pow5))
+BZ_DEFINE_UNARY_FUNC(Fn_pow6,BZ_BLITZ_SCOPE(blitz_pow6))
+BZ_DEFINE_UNARY_FUNC(Fn_pow7,BZ_BLITZ_SCOPE(blitz_pow7))
+BZ_DEFINE_UNARY_FUNC(Fn_pow8,BZ_BLITZ_SCOPE(blitz_pow8))
+
+/* Unary functions that return a specified type */
+    
+#define BZ_DEFINE_UNARY_FUNC_RET(name,fun,ret)                 \
+template<typename T_numtype1>                                  \
+struct name {                                                  \
+    typedef ret T_numtype;                                     \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return fun(a); }                                         \
+							       \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};
+
+#ifdef BZ_HAVE_IEEE_MATH
+BZ_DEFINE_UNARY_FUNC_RET(Fn_ilogb,BZ_IEEEMATHFN_SCOPE(ilogb),int)
+#endif
+    
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+BZ_DEFINE_UNARY_FUNC_RET(Fn_itrunc,BZ_IEEEMATHFN_SCOPE(itrunc),int)
+BZ_DEFINE_UNARY_FUNC_RET(Fn_uitrunc,BZ_IEEEMATHFN_SCOPE(uitrunc),unsigned int)
+#endif
+    
+    
+#ifdef BZ_HAVE_COMPLEX
+/* Specialization of unary functor for complex type */
+    
+#define BZ_DEFINE_UNARY_CFUNC(name,fun)                        \
+template<typename T>                                           \
+struct name< complex<T> > {                                    \
+    typedef complex<T> T_numtype1;                             \
+    typedef complex<T> T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return fun(a); }                                         \
+							       \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};
+
+#ifdef BZ_HAVE_COMPLEX_FCNS
+BZ_DEFINE_UNARY_FUNC(Fn_conj,BZ_CMATHFN_SCOPE(conj))
+#endif
+
+#ifdef BZ_HAVE_COMPLEX_MATH1
+BZ_DEFINE_UNARY_CFUNC(Fn_cos,BZ_CMATHFN_SCOPE(cos))
+BZ_DEFINE_UNARY_CFUNC(Fn_cosh,BZ_CMATHFN_SCOPE(cosh))
+BZ_DEFINE_UNARY_CFUNC(Fn_exp,BZ_CMATHFN_SCOPE(exp))
+BZ_DEFINE_UNARY_CFUNC(Fn_log,BZ_CMATHFN_SCOPE(log))
+BZ_DEFINE_UNARY_CFUNC(Fn_log10,BZ_CMATHFN_SCOPE(log10))
+BZ_DEFINE_UNARY_CFUNC(Fn_sin,BZ_CMATHFN_SCOPE(sin))
+BZ_DEFINE_UNARY_CFUNC(Fn_sinh,BZ_CMATHFN_SCOPE(sinh))
+BZ_DEFINE_UNARY_CFUNC(Fn_sqrt,BZ_CMATHFN_SCOPE(sqrt))
+BZ_DEFINE_UNARY_CFUNC(Fn_tan,BZ_CMATHFN_SCOPE(tan))
+BZ_DEFINE_UNARY_CFUNC(Fn_tanh,BZ_CMATHFN_SCOPE(tanh))
+#endif // BZ_HAVE_COMPLEX_MATH1
+
+BZ_DEFINE_UNARY_CFUNC(Fn_sqr,BZ_BLITZ_SCOPE(blitz_sqr))
+BZ_DEFINE_UNARY_CFUNC(Fn_cube,BZ_BLITZ_SCOPE(blitz_cube))
+BZ_DEFINE_UNARY_CFUNC(Fn_pow4,BZ_BLITZ_SCOPE(blitz_pow4))
+BZ_DEFINE_UNARY_CFUNC(Fn_pow5,BZ_BLITZ_SCOPE(blitz_pow5))
+BZ_DEFINE_UNARY_CFUNC(Fn_pow6,BZ_BLITZ_SCOPE(blitz_pow6))
+BZ_DEFINE_UNARY_CFUNC(Fn_pow7,BZ_BLITZ_SCOPE(blitz_pow7))
+BZ_DEFINE_UNARY_CFUNC(Fn_pow8,BZ_BLITZ_SCOPE(blitz_pow8))
+
+/* Unary functions that apply only to complex<T> and return T */
+    
+#define BZ_DEFINE_UNARY_CFUNC2(name,fun)                       \
+template<typename T_numtype1>                                  \
+struct name;                                                   \
+                                                               \
+template<typename T>                                           \
+struct name< complex<T> > {                                    \
+    typedef complex<T> T_numtype1;                             \
+    typedef T T_numtype;                                       \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return fun(a); }                                         \
+							       \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};
+
+#ifdef BZ_HAVE_COMPLEX_FCNS
+BZ_DEFINE_UNARY_CFUNC2(Fn_arg,BZ_CMATHFN_SCOPE(arg))
+BZ_DEFINE_UNARY_CFUNC2(Fn_imag,BZ_CMATHFN_SCOPE(imag))
+BZ_DEFINE_UNARY_CFUNC2(Fn_norm,BZ_CMATHFN_SCOPE(norm))
+BZ_DEFINE_UNARY_CFUNC2(Fn_real,BZ_CMATHFN_SCOPE(real))
+#endif // BZ_HAVE_COMPLEX_FCNS
+    
+#endif // BZ_HAVE_COMPLEX
+    
+/* Binary functions that return type based on type promotion */
+    
+#define BZ_DEFINE_BINARY_FUNC(name,fun)                           \
+template<typename T_numtype1, typename T_numtype2>                \
+struct name {                                                     \
+    typedef BZ_PROMOTE(T_numtype1, T_numtype2) T_numtype;         \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(T_numtype1 a, T_numtype2 b)                             \
+    { return fun(a,b); }                                          \
+							          \
+    template<typename T1, typename T2>                            \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,     \
+        prettyPrintFormat& format, const T1& t1,                  \
+        const T2& t2)                                             \
+    {                                                             \
+        str += #fun;                                              \
+        str += "(";                                               \
+        t1.prettyPrint(str, format);                              \
+        str += ",";                                               \
+        t2.prettyPrint(str, format);                              \
+        str += ")";                                               \
+    }                                                             \
+};
+
+BZ_DEFINE_BINARY_FUNC(Fn_atan2,BZ_MATHFN_SCOPE(atan2))
+BZ_DEFINE_BINARY_FUNC(Fn_fmod,BZ_MATHFN_SCOPE(fmod))
+BZ_DEFINE_BINARY_FUNC(Fn_pow,BZ_MATHFN_SCOPE(pow))
+    
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+BZ_DEFINE_BINARY_FUNC(Fn_copysign,BZ_IEEEMATHFN_SCOPE(copysign))
+BZ_DEFINE_BINARY_FUNC(Fn_drem,BZ_IEEEMATHFN_SCOPE(drem))
+BZ_DEFINE_BINARY_FUNC(Fn_hypot,BZ_IEEEMATHFN_SCOPE(hypot))
+BZ_DEFINE_BINARY_FUNC(Fn_nextafter,BZ_IEEEMATHFN_SCOPE(nextafter))
+BZ_DEFINE_BINARY_FUNC(Fn_remainder,BZ_IEEEMATHFN_SCOPE(remainder))
+BZ_DEFINE_BINARY_FUNC(Fn_scalb,BZ_IEEEMATHFN_SCOPE(scalb))
+#endif
+    
+/* Binary functions that return a specified type */
+    
+#define BZ_DEFINE_BINARY_FUNC_RET(name,fun,ret)                   \
+template<typename T_numtype1, typename T_numtype2>                \
+struct name {                                                     \
+    typedef ret T_numtype;                                        \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(T_numtype1 a, T_numtype2 b)                             \
+    { return fun(a,b); }                                          \
+							          \
+    template<typename T1, typename T2>                            \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,     \
+        prettyPrintFormat& format, const T1& t1,                  \
+        const T2& t2)                                             \
+    {                                                             \
+        str += #fun;                                              \
+        str += "(";                                               \
+        t1.prettyPrint(str, format);                              \
+        str += ",";                                               \
+        t2.prettyPrint(str, format);                              \
+        str += ")";                                               \
+    }                                                             \
+};
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+BZ_DEFINE_BINARY_FUNC_RET(Fn_unordered,BZ_IEEEMATHFN_SCOPE(unordered),int)
+#endif
+    
+#ifdef BZ_HAVE_COMPLEX
+/* Specialization of binary functor for complex type */
+    
+#define BZ_DEFINE_BINARY_CFUNC(name,fun)                       \
+template<typename T>                                           \
+struct name< complex<T>, complex<T> > {                        \
+    typedef complex<T> T_numtype1;                             \
+    typedef complex<T> T_numtype2;                             \
+    typedef complex<T> T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a, T_numtype2 b)                          \
+    { return fun(a,b); }                                       \
+							       \
+    template<typename T1, typename T2>                         \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1,               \
+        const T2& t2)                                          \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ",";                                            \
+        t2.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};                                                             \
+                                                               \
+template<typename T>                                           \
+struct name< complex<T>, T > {                                 \
+    typedef complex<T> T_numtype1;                             \
+    typedef T T_numtype2;                                      \
+    typedef complex<T> T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a, T_numtype2 b)                          \
+    { return fun(a,b); }                                       \
+							       \
+    template<typename T1, typename T2>                         \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1,               \
+        const T2& t2)                                          \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ",";                                            \
+        t2.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};                                                             \
+                                                               \
+template<typename T>                                           \
+struct name< T, complex<T> > {                                 \
+    typedef T T_numtype1;                                      \
+    typedef complex<T> T_numtype2;                             \
+    typedef complex<T> T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a, T_numtype2 b)                          \
+    { return fun(a,b); }                                       \
+							       \
+    template<typename T1, typename T2>                         \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1,               \
+        const T2& t2)                                          \
+    {                                                          \
+        str += #fun;                                           \
+        str += "(";                                            \
+        t1.prettyPrint(str, format);                           \
+        str += ",";                                            \
+        t2.prettyPrint(str, format);                           \
+        str += ")";                                            \
+    }                                                          \
+};
+
+#ifdef BZ_HAVE_COMPLEX_MATH1
+BZ_DEFINE_BINARY_CFUNC(Fn_pow,BZ_CMATHFN_SCOPE(pow))
+#endif
+
+/* Binary functions that apply only to T and return complex<T> */
+    
+#define BZ_DEFINE_BINARY_FUNC_CRET(name,fun)                      \
+template<typename T_numtype1, typename T_numtype2>                \
+struct name;                                                      \
+                                                                  \
+template<typename T>                                              \
+struct name<T, T> {                                               \
+    typedef T T_numtype1;                                         \
+    typedef T T_numtype2;                                         \
+    typedef complex<T> T_numtype;                                 \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(T_numtype1 a, T_numtype2 b)                             \
+    { return fun(a,b); }                                          \
+							          \
+    template<typename T1, typename T2>                            \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,     \
+        prettyPrintFormat& format, const T1& t1,                  \
+        const T2& t2)                                             \
+    {                                                             \
+        str += #fun;                                              \
+        str += "(";                                               \
+        t1.prettyPrint(str, format);                              \
+        str += ",";                                               \
+        t2.prettyPrint(str, format);                              \
+        str += ")";                                               \
+    }                                                             \
+};
+
+#ifdef BZ_HAVE_COMPLEX_FCNS
+BZ_DEFINE_BINARY_FUNC_CRET(Fn_polar,BZ_CMATHFN_SCOPE(polar))
+#endif
+    
+#endif // BZ_HAVE_COMPLEX
+    
+/* Ternary functions that return type based on type promotion */
+    
+#define BZ_DEFINE_TERNARY_FUNC(name,fun)                          \
+template <typename P_numtype1, typename P_numtype2,               \
+          typename P_numtype3>                                    \
+struct name {                                                     \
+    typedef BZ_PROMOTE(P_numtype1,                                \
+            BZ_PROMOTE(P_numtype2,P_numtype3)) T_numtype;         \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(P_numtype1 x, P_numtype2 y, P_numtype3 z)               \
+    { return fun(x,y,z); }                                        \
+                                                                  \
+    template <typename T1, typename T2, typename T3>              \
+    static void prettyPrint(BZ_STD_SCOPE(string) &str,            \
+        prettyPrintFormat& format,                                \
+        const T1& a,const T2& b, const T3& c)                     \
+    {                                                             \
+        str += #fun;                                              \
+        str += "(";                                               \
+        a.prettyPrint(str,format);                                \
+        str += ",";                                               \
+        b.prettyPrint(str,format);                                \
+        str += ",";                                               \
+        c.prettyPrint(str,format);                                \
+        str += ")";                                               \
+    }                                                             \
+};
+
+/* Ternary functions that return a specified type */
+    
+#define BZ_DEFINE_TERNARY_FUNC_RET(name,fun,ret)                  \
+template <typename P_numtype1, typename P_numtype2,               \
+          typename P_numtype3>                                    \
+struct name {                                                     \
+    typedef ret T_numtype;                                        \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(P_numtype1 x, P_numtype2 y, P_numtype3 z)               \
+    { return fun(x,y,z); }                                        \
+                                                                  \
+    template <typename T1, typename T2, typename T3>              \
+    static void prettyPrint(BZ_STD_SCOPE(string) &str,            \
+        prettyPrintFormat& format,                                \
+        const T1& a,const T2& b, const T3& c)                     \
+    {                                                             \
+        str += #fun;                                              \
+        str += "(";                                               \
+        a.prettyPrint(str,format);                                \
+        str += ",";                                               \
+        b.prettyPrint(str,format);                                \
+        str += ",";                                               \
+        c.prettyPrint(str,format);                                \
+        str += ")";                                               \
+    }                                                             \
+};
+
+    
+/* These functions don't quite fit the usual patterns */
+    
+// abs()    Absolute value
+template<typename T_numtype1>
+struct Fn_abs;
+
+// abs(int)
+template<>
+struct Fn_abs< int > {
+    typedef int T_numtype1;
+    typedef int T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_MATHFN_SCOPE(abs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+// abs(long)
+template<>
+struct Fn_abs< long int > {
+    typedef long int T_numtype1;
+    typedef long int T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_MATHFN_SCOPE(labs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+// abs(float)
+template<>
+struct Fn_abs< float > {
+    typedef float T_numtype1;
+    typedef float T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_MATHFN_SCOPE(fabs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+// abs(double)
+template<>
+struct Fn_abs< double > {
+    typedef double T_numtype1;
+    typedef double T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_MATHFN_SCOPE(fabs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+// abs(long double)
+template<>
+struct Fn_abs< long double > {
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_MATHFN_SCOPE(fabs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+#ifdef BZ_HAVE_COMPLEX_FCNS
+// abs(complex<T>)
+template<typename T>
+struct Fn_abs< complex<T> > {
+    typedef complex<T> T_numtype1;
+    typedef T T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return BZ_CMATHFN_SCOPE(abs)(a); }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "abs";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+#endif // BZ_HAVE_COMPLEX_FCNS
+
+
+#ifdef BZ_HAVE_IEEE_MATH
+// isnan()    Nonzero if NaNS or NaNQ
+template<typename T_numtype1>
+struct Fn_isnan {
+    typedef int T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    {
+#ifdef BZ_ISNAN_IN_NAMESPACE_STD
+        return BZ_STD_SCOPE(isnan)(a);
+#else
+        return BZ_IEEEMATHFN_SCOPE(isnan)(a);
+#endif
+    }
+    
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += "isnan";
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+#endif // BZ_HAVE_IEEE_MATH
+
+
+// Blitz cast() function
+template<typename T_numtype1, typename T_cast>
+struct Cast {
+    typedef T_cast T_numtype;
+    
+    static inline T_numtype
+    apply(T_numtype1 a)
+    { return T_numtype(a); }
+
+    template<typename T1>
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,
+        prettyPrintFormat& format, const T1& t1)
+    {
+        str += BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_cast);
+        str += "(";
+        t1.prettyPrint(str, format);
+        str += ")";
+    }
+};
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_FUNCS_H
Index: /XMLIO_V2/external/include/blitz/indexexpr.h
===================================================================
--- /XMLIO_V2/external/include/blitz/indexexpr.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/indexexpr.h	(revision 73)
@@ -0,0 +1,175 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/indexexpr.h     Declaration of the IndexPlaceholder<N> class
+ *
+ * $Id: indexexpr.h,v 1.7 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    p://seurat.uhttwaterloo.ca/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_INDEXEXPR_H
+#define BZ_INDEXEXPR_H
+
+#include <blitz/tinyvec.h>
+#include <blitz/prettyprint.h>
+#include <blitz/etbase.h>
+
+BZ_NAMESPACE(blitz)
+
+template<int N>
+class IndexPlaceholder 
+#ifdef BZ_NEW_EXPRESSION_TEMPLATES
+  : public ETBase<IndexPlaceholder<N> > 
+#endif
+{
+public:
+    IndexPlaceholder()
+    { }
+
+#ifdef BZ_NEW_EXPRESSION_TEMPLATES
+    IndexPlaceholder(const IndexPlaceholder<N>& x)
+        : ETBase< IndexPlaceholder<N> >(x)
+    { }
+#else
+    IndexPlaceholder(const IndexPlaceholder<N>&)
+    { }
+#endif
+
+    ~IndexPlaceholder()
+    { }
+
+    void operator=(const IndexPlaceholder<N>&)
+    { }
+
+    typedef int T_numtype;
+    typedef int T_ctorArg1;     // Dummy; not used
+    typedef int T_ctorArg2;     // Ditto
+
+    static const int 
+        numArrayOperands = 0, 
+        numIndexPlaceholders = 1,
+        rank = N+1;
+
+    // If you have a precondition failure on this routine, it means
+    // you are trying to use stack iteration mode on an expression
+    // which contains an index placeholder.  You must use index 
+    // iteration mode instead.
+    int operator*() { 
+        BZPRECONDITION(0); 
+        return 0;
+    }
+
+#ifdef BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE
+    template<int N_rank>
+    T_numtype operator()(TinyVector<int, N_rank> i) { return i[N]; }
+#else
+    template<int N_rank>
+    T_numtype operator()(const TinyVector<int, N_rank>& i) { return i[N]; }
+#endif
+
+    int ascending(int) const { return INT_MIN; }
+    int ordering(int)  const { return INT_MIN; }
+    int lbound(int)    const { return INT_MIN; }  // tiny(int());
+    int ubound(int)    const { return INT_MAX; }  // huge(int()); 
+
+    // See operator*() note
+
+    void push(int)       { BZPRECONDITION(0); }
+    void pop(int)        { BZPRECONDITION(0); }
+    void advance()       { BZPRECONDITION(0); }
+    void advance(int)    { BZPRECONDITION(0); }
+    void loadStride(int) { BZPRECONDITION(0); }
+
+    bool isUnitStride(int) const { 
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    void advanceUnitStride() { BZPRECONDITION(0); }
+
+    bool canCollapse(int,int) const {   
+        BZPRECONDITION(0); 
+        return false; 
+    }
+
+    T_numtype operator[](int) {
+        BZPRECONDITION(0);
+        return T_numtype();
+    }
+
+    T_numtype fastRead(int) {
+        BZPRECONDITION(0);
+        return T_numtype();
+    }
+
+    int suggestStride(int) const {
+        BZPRECONDITION(0);
+        return 0;
+    }
+
+    bool isStride(int,int) const {
+        BZPRECONDITION(0);
+        return true;
+    }
+
+    void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat&) const {
+        // NEEDS_WORK-- do real formatting for reductions
+        str += "index-expr[NEEDS_WORK]";
+    }
+
+    template<typename T_shape>
+    bool shapeCheck(const T_shape&) const { return true; }
+};
+
+typedef IndexPlaceholder<0> firstIndex;
+typedef IndexPlaceholder<1> secondIndex;
+typedef IndexPlaceholder<2> thirdIndex;
+typedef IndexPlaceholder<3> fourthIndex;
+typedef IndexPlaceholder<4> fifthIndex;
+typedef IndexPlaceholder<5> sixthIndex;
+typedef IndexPlaceholder<6> seventhIndex;
+typedef IndexPlaceholder<7> eighthIndex;
+typedef IndexPlaceholder<8> ninthIndex;
+typedef IndexPlaceholder<9> tenthIndex;
+typedef IndexPlaceholder<10> eleventhIndex;
+
+#ifndef BZ_NO_TENSOR_INDEX_OBJECTS
+
+BZ_NAMESPACE(tensor)
+    _bz_global blitz::IndexPlaceholder<0> i;
+    _bz_global blitz::IndexPlaceholder<1> j;
+    _bz_global blitz::IndexPlaceholder<2> k;
+    _bz_global blitz::IndexPlaceholder<3> l;
+    _bz_global blitz::IndexPlaceholder<4> m;
+    _bz_global blitz::IndexPlaceholder<5> n;
+    _bz_global blitz::IndexPlaceholder<6> o;
+    _bz_global blitz::IndexPlaceholder<7> p;
+    _bz_global blitz::IndexPlaceholder<8> q;
+    _bz_global blitz::IndexPlaceholder<9> r;
+    _bz_global blitz::IndexPlaceholder<10> s;
+    _bz_global blitz::IndexPlaceholder<11> t;
+BZ_NAMESPACE_END // tensor
+
+#endif
+
+BZ_NAMESPACE_END
+
+#endif // BZ_INDEXEXPR_H
+
Index: /XMLIO_V2/external/include/blitz/limits-hack.h
===================================================================
--- /XMLIO_V2/external/include/blitz/limits-hack.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/limits-hack.h	(revision 73)
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is not portable code.  Parts of numeric_limits<> are
+ * inherently machine-dependent, and this file is written for the MIPS
+ * architecture and the SGI MIPSpro C++ compiler.  Parts of it (in
+ * particular, some of the characteristics of floating-point types)
+ * are almost certainly incorrect for any other platform.
+ */
+
+#include <blitz/wrap-climits.h> 
+#include <float.h>
+
+BZ_NAMESPACE(std)
+
+enum float_round_style {
+  round_indeterminate       = -1,
+  round_toward_zero         =  0,
+  round_to_nearest          =  1,
+  round_toward_infinity     =  2,
+  round_toward_neg_infinity =  3
+};
+
+enum float_denorm_style {
+  denorm_indeterminate = -1,
+  denorm_absent        =  0,
+  denorm_present       =  1
+};
+
+// Base class for all specializations of numeric_limits.
+
+template <typename __number>
+class _Numeric_limits_base {
+public:
+  static const bool is_specialized = false;
+
+  static __number min()  { return __number(); }
+  static __number max()  { return __number(); }
+
+  static const int digits   = 0;
+  static const int digits10 = 0;
+
+  static const bool is_signed  = false;
+  static const bool is_integer = false;
+  static const bool is_exact   = false;
+
+  static const int radix = 0;
+
+  static __number epsilon()      { return __number(); }
+  static __number round_error()  { return __number(); }
+
+  static const int min_exponent   = 0;
+  static const int min_exponent10 = 0;
+  static const int max_exponent   = 0;
+  static const int max_exponent10 = 0;
+
+  static const bool has_infinity      = false;
+  static const bool has_quiet_NaN     = false;
+  static const bool has_signaling_NaN = false;
+  static const float_denorm_style has_denorm = denorm_absent;
+  static const bool has_denorm_loss   = false;
+
+  static __number infinity()       { return __number(); }
+  static __number quiet_NaN()      { return __number(); }
+  static __number signaling_NaN()  { return __number(); }
+  static __number denorm_min()     { return __number(); }
+
+  static const bool is_iec559  = false;
+  static const bool is_bounded = false;
+  static const bool is_modulo  = false;
+
+  static const bool traps           = false;
+  static const bool tinyness_before = false;
+  static const float_round_style round_style = round_toward_zero;
+};
+
+#define __declare_numeric_base_member(__type, __mem) \
+template <typename __number> \
+  const __type _Numeric_limits_base<__number>:: __mem
+
+__declare_numeric_base_member(bool, is_specialized);
+__declare_numeric_base_member(int, digits);
+__declare_numeric_base_member(int, digits10);
+__declare_numeric_base_member(bool, is_signed);
+__declare_numeric_base_member(bool, is_integer);
+__declare_numeric_base_member(bool, is_exact);
+__declare_numeric_base_member(int, radix);
+__declare_numeric_base_member(int, min_exponent);
+__declare_numeric_base_member(int, max_exponent);
+__declare_numeric_base_member(int, min_exponent10);
+__declare_numeric_base_member(int, max_exponent10);
+__declare_numeric_base_member(bool, has_infinity);
+__declare_numeric_base_member(bool, has_quiet_NaN);
+__declare_numeric_base_member(bool, has_signaling_NaN);
+__declare_numeric_base_member(float_denorm_style, has_denorm);
+__declare_numeric_base_member(bool, has_denorm_loss);
+__declare_numeric_base_member(bool, is_iec559);
+__declare_numeric_base_member(bool, is_bounded);
+__declare_numeric_base_member(bool, is_modulo);
+__declare_numeric_base_member(bool, traps);
+__declare_numeric_base_member(bool, tinyness_before);
+__declare_numeric_base_member(float_round_style, round_style);
+
+#undef __declare_numeric_base_member
+
+// Base class for integers.
+
+template <typename _Int,
+          _Int __imin,
+          _Int __imax,
+          int __idigits = -1>
+class _Integer_limits : public _Numeric_limits_base<_Int> {
+public:
+  static const bool is_specialized = true;
+
+  static _Int min()  { return __imin; }
+  static _Int max()  { return __imax; }
+
+  static const int digits = 
+    (__idigits < 0) ? sizeof(_Int) * CHAR_BIT - (__imin == 0 ? 0 : 1) 
+                    : __idigits;
+  static const int digits10 = (digits * 301) / 1000; 
+                                // log 2 = 0.301029995664...
+
+  static const bool is_signed = __imin != 0;
+  static const bool is_integer = true;
+  static const bool is_exact = true;
+  static const int radix = 2;
+
+
+  static const bool is_bounded = true;
+  static const bool is_modulo = true;
+};
+
+#define __declare_integer_limits_member(__type, __mem) \
+template <typename _Int, _Int __imin, _Int __imax, int __idigits> \
+  const __type _Integer_limits<_Int, __imin, __imax, __idigits>:: __mem
+
+__declare_integer_limits_member(bool, is_specialized);
+__declare_integer_limits_member(int, digits);
+__declare_integer_limits_member(int, digits10);
+__declare_integer_limits_member(bool, is_signed);
+__declare_integer_limits_member(bool, is_integer);
+__declare_integer_limits_member(bool, is_exact);
+__declare_integer_limits_member(int, radix);
+__declare_integer_limits_member(bool, is_bounded);
+__declare_integer_limits_member(bool, is_modulo);
+
+#undef __declare_integer_limits_member
+
+// Base class for floating-point numbers.
+template <typename __number,
+         int __Digits, int __Digits10,
+         int __MinExp, int __MaxExp,
+         int __MinExp10, int __MaxExp10,
+         unsigned int __InfinityWord,
+         unsigned int __QNaNWord, unsigned int __SNaNWord,
+         bool __IsIEC559,
+         float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number>
+{
+public:
+  static const bool is_specialized = true;
+
+  static const int digits   = __Digits;
+  static const int digits10 = __Digits10;
+
+  static const bool is_signed = true;
+
+  static const int radix = 2;
+
+  static const int min_exponent   = __MinExp;
+  static const int max_exponent   = __MaxExp;
+  static const int min_exponent10 = __MinExp10;
+  static const int max_exponent10 = __MaxExp10;
+
+  static const bool has_infinity      = true;
+  static const bool has_quiet_NaN     = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = denorm_indeterminate;
+  static const bool has_denorm_loss   = false;
+
+  static __number infinity()  {
+    static unsigned int _S_inf[sizeof(__number) / sizeof(int)] = 
+      { __InfinityWord };
+    return *reinterpret_cast<__number*>(&_S_inf);
+  }
+  static __number quiet_NaN()  {
+    static unsigned int _S_nan[sizeof(__number) / sizeof(int)] = 
+      { __QNaNWord };
+    return *reinterpret_cast<__number*>(&_S_nan);
+  }
+  static __number signaling_NaN()  {
+    static unsigned int _S_nan[sizeof(__number) / sizeof(int)] = 
+      { __SNaNWord };
+    return *reinterpret_cast<__number*>(&_S_nan);
+  }
+
+  static const bool is_iec559       = __IsIEC559;
+  static const bool is_bounded      = true;
+  static const bool traps           = true;
+  static const bool tinyness_before = false;
+
+  static const float_round_style round_style = __RoundStyle;
+};
+
+#define __declare_float_limits_member(__type, __mem) \
+template <typename __Num, int __Dig, int __Dig10, \
+          int __MnX, int __MxX, int __MnX10, int __MxX10, \
+          unsigned int __Inf, unsigned int __QNaN, unsigned int __SNaN, \
+          bool __IsIEEE, float_round_style __Sty> \
+const __type _Floating_limits<__Num, __Dig, __Dig10, \
+                              __MnX, __MxX, __MnX10, __MxX10, \
+                              __Inf, __QNaN, __SNaN,__IsIEEE, __Sty>:: __mem
+
+__declare_float_limits_member(bool, is_specialized);  
+__declare_float_limits_member(int, digits);  
+__declare_float_limits_member(int, digits10);  
+__declare_float_limits_member(bool, is_signed);  
+__declare_float_limits_member(int, radix);  
+__declare_float_limits_member(int, min_exponent);  
+__declare_float_limits_member(int, max_exponent);  
+__declare_float_limits_member(int, min_exponent10);  
+__declare_float_limits_member(int, max_exponent10);  
+__declare_float_limits_member(bool, has_infinity);
+__declare_float_limits_member(bool, has_quiet_NaN);
+__declare_float_limits_member(bool, has_signaling_NaN);
+__declare_float_limits_member(float_denorm_style, has_denorm);
+__declare_float_limits_member(bool, has_denorm_loss);
+__declare_float_limits_member(bool, is_iec559);
+__declare_float_limits_member(bool, is_bounded);
+__declare_float_limits_member(bool, traps);
+__declare_float_limits_member(bool, tinyness_before);
+__declare_float_limits_member(float_round_style, round_style);
+
+#undef __declare_float_limits_member
+
+// Class numeric_limits
+
+// The unspecialized class.
+
+template<typename T> 
+class numeric_limits : public _Numeric_limits_base<T> {};
+
+// Specializations for all built-in integral types.
+
+#ifndef __STL_NO_BOOL
+
+template<>
+class numeric_limits<bool>
+  : public _Integer_limits<bool, false, true, 0> {};
+
+#endif /* __STL_NO_BOOL */
+
+template<>
+class numeric_limits<char>
+  : public _Integer_limits<char, CHAR_MIN, CHAR_MAX> {};
+
+template<>
+class numeric_limits<signed char>
+  : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX> {};
+
+template<>
+class numeric_limits<unsigned char>
+  : public _Integer_limits<unsigned char, 0, UCHAR_MAX> {};
+
+#ifdef __STL_HAS_WCHAR_T
+
+template<>
+class numeric_limits<wchar_t>
+  : public _Integer_limits<wchar_t, INT_MIN, INT_MAX> {};
+
+#endif
+
+template<>
+class numeric_limits<short>
+  : public _Integer_limits<short, SHRT_MIN, SHRT_MAX> {};
+
+template<>
+class numeric_limits<unsigned short>
+  : public _Integer_limits<unsigned short, 0, USHRT_MAX> {};
+
+template<>
+class numeric_limits<int>
+  : public _Integer_limits<int, INT_MIN, INT_MAX> {};
+
+template<>
+class numeric_limits<unsigned int>
+  : public _Integer_limits<unsigned int, 0, UINT_MAX> {};
+
+template<>
+class numeric_limits<long>
+  : public _Integer_limits<long, LONG_MIN, LONG_MAX> {};
+
+template<>
+class numeric_limits<unsigned long>
+  : public _Integer_limits<unsigned long, 0, ULONG_MAX> {};
+
+#ifdef __STL_LONG_LONG
+#ifdef LONG_LONG_MIN
+
+// CYGNUS LOCAL 9/4/1998
+// fixed LONGLONG to be LONG_LONG
+template<>
+class numeric_limits<long long>
+  : public _Integer_limits<long long, LONG_LONG_MIN, LONG_LONG_MAX> {};
+
+// CYGNUS LOCAL 9/4/1998
+// fixed LONGLONG to be LONG_LONG
+template<>
+class numeric_limits<unsigned long long>
+  : public _Integer_limits<unsigned long long, 0, ULONG_LONG_MAX> {};
+
+#endif
+#endif /* __STL_LONG_LONG */
+
+// Specializations for all built-in floating-point type.
+
+template<> class numeric_limits<float>
+  : public _Floating_limits<float, 
+                            FLT_MANT_DIG,   // Binary digits of precision
+                            FLT_DIG,        // Decimal digits of precision
+                            FLT_MIN_EXP,    // Minimum exponent
+                            FLT_MAX_EXP,    // Maximum exponent
+                            FLT_MIN_10_EXP, // Minimum base 10 exponent
+                            FLT_MAX_10_EXP, // Maximum base 10 exponent
+                            0x7f800000u,    // First word of +infinity
+                            0x7f810000u,    // First word of quiet NaN
+                            0x7fc10000u,    // First word of signaling NaN
+                            true,           // conforms to iec559
+                            round_to_nearest>
+{
+public:
+  static float min()  { return FLT_MIN; }
+  static float denorm_min()  { return FLT_MIN; }
+  static float max()  { return FLT_MAX; }
+  static float epsilon()  { return FLT_EPSILON; }
+  static float round_error()  { return 0.5f; } // Units: ulps.
+};
+
+template<> class numeric_limits<double>
+  : public _Floating_limits<double, 
+                            DBL_MANT_DIG,   // Binary digits of precision
+                            DBL_DIG,        // Decimal digits of precision
+                            DBL_MIN_EXP,    // Minimum exponent
+                            DBL_MAX_EXP,    // Maximum exponent
+                            DBL_MIN_10_EXP, // Minimum base 10 exponent
+                            DBL_MAX_10_EXP, // Maximum base 10 exponent
+                            0x7ff00000u,    // First word of +infinity
+                            0x7ff10000u,    // First word of quiet NaN
+                            0x7ff90000u,    // First word of signaling NaN
+                            true,           // conforms to iec559
+                            round_to_nearest>
+{
+public:
+  static double min()  { return DBL_MIN; }
+  static double denorm_min()  { return DBL_MIN; }
+  static double max()  { return DBL_MAX; }
+  static double epsilon()  { return DBL_EPSILON; }
+  static double round_error()  { return 0.5; } // Units: ulps.
+};
+
+template<> class numeric_limits<long double>
+  : public _Floating_limits<long double, 
+                            LDBL_MANT_DIG,  // Binary digits of precision
+                            LDBL_DIG,       // Decimal digits of precision
+                            LDBL_MIN_EXP,   // Minimum exponent
+                            LDBL_MAX_EXP,   // Maximum exponent
+                            LDBL_MIN_10_EXP,// Minimum base 10 exponent
+                            LDBL_MAX_10_EXP,// Maximum base 10 exponent
+                            0x7ff00000u,    // First word of +infinity
+                            0x7ff10000u,    // First word of quiet NaN
+                            0x7ff90000u,    // First word of signaling NaN
+                            false,          // Doesn't conform to iec559
+                            round_to_nearest>
+{
+public:
+  static long double min()  { return LDBL_MIN; }
+  static long double denorm_min()  { return LDBL_MIN; }
+  static long double max()  { return LDBL_MAX; }
+  static long double epsilon()  { return LDBL_EPSILON; }
+  static long double round_error()  { return 4; } // Units: ulps.
+};
+
+BZ_NAMESPACE_END
+
Index: /XMLIO_V2/external/include/blitz/listinit.h
===================================================================
--- /XMLIO_V2/external/include/blitz/listinit.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/listinit.h	(revision 73)
@@ -0,0 +1,113 @@
+/***************************************************************************
+ * blitz/listinit.h      Classes for initialization lists
+ *
+ * $Id: listinit.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+/*
+ * Initialization lists provide a convenient way to set the elements
+ * of an array.  For example,
+ *
+ * Array<int,2> A(3,3);
+ * A = 1, 0, 0,
+ *     0, 1, 0,
+ *     0, 0, 1;
+ */
+
+#ifndef BZ_LISTINIT_H
+#define BZ_LISTINIT_H
+
+BZ_NAMESPACE(blitz)
+
+template<typename T_numtype, typename T_iterator>
+class ListInitializer {
+
+public:
+    ListInitializer(T_iterator iter)
+        : iter_(iter)
+    {
+    }
+
+    ListInitializer<T_numtype, T_iterator> operator,(T_numtype x)
+    {
+        *iter_ = x;
+        return ListInitializer<T_numtype, T_iterator>(iter_ + 1);
+    }
+
+private:
+    ListInitializer();
+
+protected:
+    T_iterator iter_;
+};
+
+template<typename T_array, typename T_iterator = _bz_typename T_array::T_numtype*>
+class ListInitializationSwitch {
+
+public:
+    typedef _bz_typename T_array::T_numtype T_numtype;
+
+    ListInitializationSwitch(const ListInitializationSwitch<T_array>& lis)
+        : array_(lis.array_), value_(lis.value_), 
+          wipeOnDestruct_(true)
+    {
+        lis.disable();
+    }
+
+    ListInitializationSwitch(T_array& array, T_numtype value)
+        : array_(array), value_(value), wipeOnDestruct_(true)
+    { }
+
+    ~ListInitializationSwitch()
+    {
+        if (wipeOnDestruct_)
+            array_.initialize(value_);
+    }
+
+    ListInitializer<T_numtype, T_iterator> operator,(T_numtype x)
+    {
+        wipeOnDestruct_ = false;
+        T_iterator iter = array_.getInitializationIterator();
+        *iter = value_;
+        T_iterator iter2 = iter + 1;
+        *iter2 = x;
+        return ListInitializer<T_numtype, T_iterator>(iter2 + 1);
+    }
+
+    void disable() const
+    {
+        wipeOnDestruct_ = false;
+    }
+
+private:
+    ListInitializationSwitch();
+
+protected:
+    T_array& array_;
+    T_numtype value_;
+    mutable bool wipeOnDestruct_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_LISTINIT_H
+
Index: /XMLIO_V2/external/include/blitz/matbops.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matbops.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matbops.h	(revision 73)
@@ -0,0 +1,5636 @@
+// Generated source file.  Do not edit.
+// Created by: genmatbops.cpp Dec 10 2003 17:58:20
+
+#ifndef BZ_MATBOPS_H
+#define BZ_MATBOPS_H
+
+BZ_NAMESPACE(blitz)
+
+#ifndef BZ_MATEXPR_H
+ #error <blitz/matbops.h> must be included via <blitz/matexpr.h>
+#endif
+
+/****************************************************************************
+ * Addition Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> + Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> + _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> + int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Add<P_numtype1, int > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> + float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Add<P_numtype1, float > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Add<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> + double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Add<P_numtype1, double > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Add<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> + long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Add<P_numtype1, long double > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Add<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> + complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Add<P_numtype1, complex<T2>  > > >
+operator+(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Add<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> + Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2 > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> + _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> + int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Add<typename P_expr1::T_numtype, int > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Add<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> + float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Add<typename P_expr1::T_numtype, float > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Add<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> + double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Add<typename P_expr1::T_numtype, double > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Add<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> + long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Add<typename P_expr1::T_numtype, long double > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Add<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> + complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Add<typename P_expr1::T_numtype, complex<T2>  > > >
+operator+(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Add<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int + Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int + _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<int, typename P_expr2::T_numtype > > >
+operator+(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float + Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<float, P_numtype2 > > >
+operator+(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float + _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<float, typename P_expr2::T_numtype > > >
+operator+(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double + Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<double, P_numtype2 > > >
+operator+(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double + _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<double, typename P_expr2::T_numtype > > >
+operator+(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double + Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<long double, P_numtype2 > > >
+operator+(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double + _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<long double, typename P_expr2::T_numtype > > >
+operator+(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Add<complex<T1> , P_numtype2 > > >
+operator+(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Add<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Add<complex<T1> , typename P_expr2::T_numtype > > >
+operator+(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Add<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Subtraction Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> - Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> - _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> - int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> - float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Subtract<P_numtype1, float > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Subtract<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> - double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Subtract<P_numtype1, double > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Subtract<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> - long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Subtract<P_numtype1, long double > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Subtract<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> - complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Subtract<P_numtype1, complex<T2>  > > >
+operator-(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Subtract<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> - Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> - _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> - int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Subtract<typename P_expr1::T_numtype, int > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Subtract<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> - float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Subtract<typename P_expr1::T_numtype, float > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Subtract<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> - double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Subtract<typename P_expr1::T_numtype, double > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Subtract<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> - long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Subtract<typename P_expr1::T_numtype, long double > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Subtract<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> - complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Subtract<typename P_expr1::T_numtype, complex<T2>  > > >
+operator-(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int - Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int - _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<int, typename P_expr2::T_numtype > > >
+operator-(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float - Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<float, P_numtype2 > > >
+operator-(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float - _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<float, typename P_expr2::T_numtype > > >
+operator-(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double - Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<double, P_numtype2 > > >
+operator-(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double - _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<double, typename P_expr2::T_numtype > > >
+operator-(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double - Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<long double, P_numtype2 > > >
+operator-(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double - _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<long double, typename P_expr2::T_numtype > > >
+operator-(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Subtract<complex<T1> , P_numtype2 > > >
+operator-(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Subtract<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Subtract<complex<T1> , typename P_expr2::T_numtype > > >
+operator-(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Subtract<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Multiplication Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> * Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> * _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> * int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> * float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Multiply<P_numtype1, float > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Multiply<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> * double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Multiply<P_numtype1, double > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Multiply<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> * long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Multiply<P_numtype1, long double > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Multiply<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> * complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Multiply<P_numtype1, complex<T2>  > > >
+operator*(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Multiply<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> * Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> * _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> * int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Multiply<typename P_expr1::T_numtype, int > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Multiply<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> * float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Multiply<typename P_expr1::T_numtype, float > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Multiply<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> * double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Multiply<typename P_expr1::T_numtype, double > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Multiply<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> * long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Multiply<typename P_expr1::T_numtype, long double > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Multiply<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> * complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Multiply<typename P_expr1::T_numtype, complex<T2>  > > >
+operator*(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int * Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int * _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<int, typename P_expr2::T_numtype > > >
+operator*(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float * Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<float, P_numtype2 > > >
+operator*(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float * _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<float, typename P_expr2::T_numtype > > >
+operator*(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double * Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<double, P_numtype2 > > >
+operator*(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double * _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<double, typename P_expr2::T_numtype > > >
+operator*(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double * Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<long double, P_numtype2 > > >
+operator*(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double * _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<long double, typename P_expr2::T_numtype > > >
+operator*(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Multiply<complex<T1> , P_numtype2 > > >
+operator*(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Multiply<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Multiply<complex<T1> , typename P_expr2::T_numtype > > >
+operator*(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Multiply<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Division Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> / Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> / _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> / int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> / float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Divide<P_numtype1, float > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Divide<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> / double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Divide<P_numtype1, double > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Divide<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> / long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Divide<P_numtype1, long double > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Divide<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> / complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Divide<P_numtype1, complex<T2>  > > >
+operator/(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Divide<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> / Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> / _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> / int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Divide<typename P_expr1::T_numtype, int > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Divide<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> / float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Divide<typename P_expr1::T_numtype, float > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Divide<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> / double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Divide<typename P_expr1::T_numtype, double > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Divide<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> / long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Divide<typename P_expr1::T_numtype, long double > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Divide<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> / complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Divide<typename P_expr1::T_numtype, complex<T2>  > > >
+operator/(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Divide<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int / Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int / _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<int, typename P_expr2::T_numtype > > >
+operator/(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float / Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<float, P_numtype2 > > >
+operator/(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float / _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<float, typename P_expr2::T_numtype > > >
+operator/(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double / Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<double, P_numtype2 > > >
+operator/(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double / _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<double, typename P_expr2::T_numtype > > >
+operator/(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double / Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<long double, P_numtype2 > > >
+operator/(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double / _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<long double, typename P_expr2::T_numtype > > >
+operator/(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Divide<complex<T1> , P_numtype2 > > >
+operator/(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Divide<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Divide<complex<T1> , typename P_expr2::T_numtype > > >
+operator/(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Divide<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Modulus Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> % Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> % _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype > > >
+operator%(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> % int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> % Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > >
+operator%(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> % _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator%(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> % int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Mod<typename P_expr1::T_numtype, int > > >
+operator%(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Mod<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int % Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int % _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Mod<int, typename P_expr2::T_numtype > > >
+operator%(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Mod<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Bitwise XOR Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> ^ Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> ^ _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > >
+operator^(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> ^ int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> ^ Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > >
+operator^(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> ^ _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator^(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> ^ int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int > > >
+operator^(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int ^ Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int ^ _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype > > >
+operator^(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Bitwise And Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> & Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> & _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> & int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> & Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> & _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator&(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> & int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int > > >
+operator&(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int & Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int & _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype > > >
+operator&(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Bitwise Or Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> | Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> | _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator|(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> | int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> | Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator|(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> | _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator|(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> | int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int > > >
+operator|(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int | Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int | _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype > > >
+operator|(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Shift right Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> >> Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> >> _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > >
+operator>>(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> >> int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> >> Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>>(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> >> _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>>(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> >> int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, int > > >
+operator>>(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int >> Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int >> _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftRight<int, typename P_expr2::T_numtype > > >
+operator>>(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftRight<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Shift left Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> << Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> << _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > >
+operator<<(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> << int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> << Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<<(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> << _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<<(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> << int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int > > >
+operator<<(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int << Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int << _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype > > >
+operator<<(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Greater-than Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> > Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> > _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> > int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> > float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Greater<P_numtype1, float > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Greater<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> > double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Greater<P_numtype1, double > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Greater<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> > long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Greater<P_numtype1, long double > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Greater<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> > complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Greater<P_numtype1, complex<T2>  > > >
+operator>(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Greater<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> > Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> > _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> > int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Greater<typename P_expr1::T_numtype, int > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Greater<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> > float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Greater<typename P_expr1::T_numtype, float > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Greater<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> > double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Greater<typename P_expr1::T_numtype, double > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Greater<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> > long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Greater<typename P_expr1::T_numtype, long double > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Greater<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> > complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Greater<typename P_expr1::T_numtype, complex<T2>  > > >
+operator>(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Greater<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int > Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int > _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<int, typename P_expr2::T_numtype > > >
+operator>(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float > Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<float, P_numtype2 > > >
+operator>(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float > _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<float, typename P_expr2::T_numtype > > >
+operator>(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double > Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<double, P_numtype2 > > >
+operator>(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double > _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<double, typename P_expr2::T_numtype > > >
+operator>(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double > Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<long double, P_numtype2 > > >
+operator>(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double > _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<long double, typename P_expr2::T_numtype > > >
+operator>(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Greater<complex<T1> , P_numtype2 > > >
+operator>(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Greater<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Greater<complex<T1> , typename P_expr2::T_numtype > > >
+operator>(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Greater<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Less-than Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> < Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> < _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> < int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Less<P_numtype1, int > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> < float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Less<P_numtype1, float > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Less<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> < double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Less<P_numtype1, double > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Less<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> < long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Less<P_numtype1, long double > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Less<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> < complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Less<P_numtype1, complex<T2>  > > >
+operator<(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Less<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> < Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> < _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> < int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Less<typename P_expr1::T_numtype, int > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Less<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> < float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Less<typename P_expr1::T_numtype, float > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Less<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> < double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Less<typename P_expr1::T_numtype, double > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Less<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> < long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Less<typename P_expr1::T_numtype, long double > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Less<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> < complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Less<typename P_expr1::T_numtype, complex<T2>  > > >
+operator<(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Less<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int < Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int < _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<int, typename P_expr2::T_numtype > > >
+operator<(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float < Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<float, P_numtype2 > > >
+operator<(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float < _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<float, typename P_expr2::T_numtype > > >
+operator<(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double < Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<double, P_numtype2 > > >
+operator<(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double < _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<double, typename P_expr2::T_numtype > > >
+operator<(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double < Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<long double, P_numtype2 > > >
+operator<(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double < _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<long double, typename P_expr2::T_numtype > > >
+operator<(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Less<complex<T1> , P_numtype2 > > >
+operator<(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Less<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Less<complex<T1> , typename P_expr2::T_numtype > > >
+operator<(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Less<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Greater or equal (>=) operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> >= Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> >= _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> >= int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> >= float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_GreaterOrEqual<P_numtype1, float > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_GreaterOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> >= double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_GreaterOrEqual<P_numtype1, double > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_GreaterOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> >= long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_GreaterOrEqual<P_numtype1, long double > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_GreaterOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> >= complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<P_numtype1, complex<T2>  > > >
+operator>=(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> >= Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> >= _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> >= int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> >= float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, float > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> >= double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, double > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> >= long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> >= complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator>=(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int >= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int >= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype > > >
+operator>=(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float >= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<float, P_numtype2 > > >
+operator>=(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float >= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<float, typename P_expr2::T_numtype > > >
+operator>=(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double >= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<double, P_numtype2 > > >
+operator>=(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double >= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<double, typename P_expr2::T_numtype > > >
+operator>=(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double >= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<long double, P_numtype2 > > >
+operator>=(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double >= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype > > >
+operator>=(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2 > > >
+operator>=(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator>=(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Less or equal (<=) operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> <= Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> <= _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> <= int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> <= float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_LessOrEqual<P_numtype1, float > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_LessOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> <= double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_LessOrEqual<P_numtype1, double > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_LessOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> <= long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_LessOrEqual<P_numtype1, long double > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_LessOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> <= complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<P_numtype1, complex<T2>  > > >
+operator<=(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> <= Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> <= _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> <= int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> <= float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, float > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> <= double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, double > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> <= long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, long double > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> <= complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator<=(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int <= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int <= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype > > >
+operator<=(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float <= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<float, P_numtype2 > > >
+operator<=(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float <= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<float, typename P_expr2::T_numtype > > >
+operator<=(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double <= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<double, P_numtype2 > > >
+operator<=(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double <= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<double, typename P_expr2::T_numtype > > >
+operator<=(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double <= Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<long double, P_numtype2 > > >
+operator<=(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double <= _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<long double, typename P_expr2::T_numtype > > >
+operator<=(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LessOrEqual<complex<T1> , P_numtype2 > > >
+operator<=(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LessOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator<=(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Equality operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> == Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> == _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> == int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> == float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Equal<P_numtype1, float > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Equal<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> == double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Equal<P_numtype1, double > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Equal<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> == long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Equal<P_numtype1, long double > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Equal<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> == complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Equal<P_numtype1, complex<T2>  > > >
+operator==(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Equal<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> == Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> == _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> == int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Equal<typename P_expr1::T_numtype, int > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Equal<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> == float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_Equal<typename P_expr1::T_numtype, float > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_Equal<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> == double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_Equal<typename P_expr1::T_numtype, double > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_Equal<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> == long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_Equal<typename P_expr1::T_numtype, long double > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_Equal<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> == complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_Equal<typename P_expr1::T_numtype, complex<T2>  > > >
+operator==(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_Equal<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int == Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int == _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<int, typename P_expr2::T_numtype > > >
+operator==(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float == Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<float, P_numtype2 > > >
+operator==(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float == _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<float, typename P_expr2::T_numtype > > >
+operator==(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double == Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<double, P_numtype2 > > >
+operator==(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double == _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<double, typename P_expr2::T_numtype > > >
+operator==(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double == Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<long double, P_numtype2 > > >
+operator==(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double == _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<long double, typename P_expr2::T_numtype > > >
+operator==(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Equal<complex<T1> , P_numtype2 > > >
+operator==(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Equal<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_Equal<complex<T1> , typename P_expr2::T_numtype > > >
+operator==(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Equal<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Not-equal operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> != Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> != _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> != int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> != float
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>,
+      _bz_NotEqual<P_numtype1, float > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_NotEqual<P_numtype1, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> != double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>,
+      _bz_NotEqual<P_numtype1, double > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_NotEqual<P_numtype1, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// Matrix<P_numtype1, P_struct1> != long double
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_NotEqual<P_numtype1, long double > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_NotEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Matrix<P_numtype1, P_struct1> != complex<T2>
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_NotEqual<P_numtype1, complex<T2>  > > >
+operator!=(const Matrix<P_numtype1, P_struct1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_NotEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_MatExpr<P_expr1> != Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> != _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> != int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_NotEqual<typename P_expr1::T_numtype, int > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> != float
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>,
+      _bz_NotEqual<typename P_expr1::T_numtype, float > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<float>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<float>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> != double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>,
+      _bz_NotEqual<typename P_expr1::T_numtype, double > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<double>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<double>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> != long double
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>,
+      _bz_NotEqual<typename P_expr1::T_numtype, long double > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<long double>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_MatExpr<P_expr1> != complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > ,
+      _bz_NotEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator!=(_bz_MatExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<complex<T2> > , 
+      _bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int != Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int != _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<int, typename P_expr2::T_numtype > > >
+operator!=(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+// float != Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<float, P_numtype2 > > >
+operator!=(float d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<float, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2._bz_getRef()));
+}
+
+// float != _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<float, typename P_expr2::T_numtype > > >
+operator!=(float d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), 
+      d2));
+}
+
+// double != Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<double, P_numtype2 > > >
+operator!=(double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2._bz_getRef()));
+}
+
+// double != _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<double, typename P_expr2::T_numtype > > >
+operator!=(double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), 
+      d2));
+}
+
+// long double != Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<long double, P_numtype2 > > >
+operator!=(long double d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2._bz_getRef()));
+}
+
+// long double != _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<long double, typename P_expr2::T_numtype > > >
+operator!=(long double d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), 
+      d2));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != Matrix<P_numtype2, P_struct2>
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_NotEqual<complex<T1> , P_numtype2 > > >
+operator!=(complex<T1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_NotEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2._bz_getRef()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != _bz_MatExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>,
+      _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator!=(complex<T1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , 
+      _bz_MatExpr<P_expr2>, 
+      _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Logical AND operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> && Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> && _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&&(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> && int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> && Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&&(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> && _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator&&(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> && int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int > > >
+operator&&(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int && Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int && _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype > > >
+operator&&(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Logical OR operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> || Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> || _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator||(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> || int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> || Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator||(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> || _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator||(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> || int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, int > > >
+operator||(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int || Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int || _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_LogicalOr<int, typename P_expr2::T_numtype > > >
+operator||(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_LogicalOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Minimum Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> min Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> min _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype > > >
+min(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> min int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Min<P_numtype1, int > > >
+min(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> min Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2 > > >
+min(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> min _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+min(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> min int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Min<typename P_expr1::T_numtype, int > > >
+min(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Min<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int min Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Min<int, P_numtype2 > > >
+min(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int min _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Min<int, typename P_expr2::T_numtype > > >
+min(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Min<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+/****************************************************************************
+ * Maximum Operators
+ ****************************************************************************/
+
+// Matrix<P_numtype1, P_struct1> max Matrix<P_numtype2, P_struct2>
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const Matrix<P_numtype1, P_struct1>& d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2._bz_getRef()));
+}
+
+// Matrix<P_numtype1, P_struct1> max _bz_MatExpr<P_expr2>
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype > > >
+max(const Matrix<P_numtype1, P_struct1>& d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      d2));
+}
+
+// Matrix<P_numtype1, P_struct1> max int
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Max<P_numtype1, int > > >
+max(const Matrix<P_numtype1, P_struct1>& d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// _bz_MatExpr<P_expr1> max Matrix<P_numtype2, P_struct2>
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2 > > >
+max(_bz_MatExpr<P_expr1> d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2._bz_getRef()));
+}
+
+// _bz_MatExpr<P_expr1> max _bz_MatExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+max(_bz_MatExpr<P_expr1> d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_MatExpr<P_expr1> max int
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>,
+      _bz_Max<typename P_expr1::T_numtype, int > > >
+max(_bz_MatExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, 
+      _bz_MatExprConstant<int>, 
+      _bz_Max<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, 
+      _bz_MatExprConstant<int>(d2)));
+}
+
+// int max Matrix<P_numtype2, P_struct2>
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>,
+      _bz_Max<int, P_numtype2 > > >
+max(int d1, 
+      const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatrixRef<P_numtype2, P_struct2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2._bz_getRef()));
+}
+
+// int max _bz_MatExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>,
+      _bz_Max<int, typename P_expr2::T_numtype > > >
+max(int d1, 
+      _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, 
+      _bz_MatExpr<P_expr2>, 
+      _bz_Max<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), 
+      d2));
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATBOPS_H
Index: /XMLIO_V2/external/include/blitz/matdiag.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matdiag.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matdiag.h	(revision 73)
@@ -0,0 +1,121 @@
+/***************************************************************************
+ * blitz/matdiag.h      Declarations for Diagonal matrices 
+ *
+ * $Id: matdiag.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATDIAG_H
+#define BZ_MATDIAG_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/matdiag.h> must be included via <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Diagonal matrix
+// [ 0 . . . ]
+// [ . 1 . . ]
+// [ . . 2 . ]
+// [ . . . 3 ]
+
+class DiagonalIterator {
+public:
+    DiagonalIterator(const unsigned rows,const unsigned cols) {
+        BZPRECONDITION(rows==cols);
+        size_ = rows;
+        i_ = 0;
+    }
+
+    operator bool() const { return i_ < size_; }
+
+    void operator++() { ++i_; }
+
+    unsigned row()    const { return i_; }
+    unsigned col()    const { return i_; }
+    unsigned offset() const { return i_; }
+
+protected:
+    unsigned i_, size_;
+};
+
+class Diagonal : public MatrixStructure {
+public:
+    typedef DiagonalIterator T_iterator;
+
+    Diagonal(): size_(0) { }
+
+    Diagonal(const unsigned size): size_(size) { }
+
+    Diagonal(const unsigned rows,const unsigned cols): size_(rows) {
+        BZPRECONDITION(rows == cols);
+    }
+
+    unsigned columns() const { return size_; }
+
+    unsigned coordToOffset(const unsigned i,const unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        BZPRECONDITION(i == j);
+        return i;
+    }
+
+    unsigned firstInRow(const unsigned i) const { return i; }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,const unsigned i,const unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return (i==j) ? data[coordToOffset(i,j)] : ZeroElement<T_numtype>::zero();
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data,const unsigned i,const unsigned j) {
+        BZPRECONDITION(inRange(i,j));
+        return (i==j) ? data[coordToOffset(i,j)] : ZeroElement<T_numtype>::zero();
+    }
+
+    unsigned lastInRow(const unsigned i)  const { return i; }
+    unsigned firstInCol(const unsigned j) const { return j; }
+    unsigned lastInCol(const unsigned j)  const { return j; }
+
+    bool inRange(const unsigned i,const unsigned j) const {
+        return (i < size_) && (j < size_);
+    }
+
+    unsigned numElements() const { return size_; }
+    unsigned rows()        const { return size_; }
+
+    void resize(const unsigned size) { size_ = size; }
+
+    void resize(const unsigned rows,const unsigned cols) {
+        BZPRECONDITION(rows == cols);
+        size_  = rows;
+    }
+
+private:
+    unsigned size_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATSYMM_H
Index: /XMLIO_V2/external/include/blitz/matexpr.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matexpr.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matexpr.h	(revision 73)
@@ -0,0 +1,173 @@
+/***************************************************************************
+ * blitz/matexpr.h      Matrix<P_numtype, P_structure> expression templates
+ *
+ * $Id: matexpr.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATEXPR_H
+#define BZ_MATEXPR_H
+
+#ifndef BZ_MATRIX_H
+ #error <blitz/matexpr.h> must be included via <blitz/matrix.h>
+#endif
+
+#include <blitz/applics.h>
+
+BZ_NAMESPACE(blitz)
+
+// BlitzMatrixExpressionsBase is a dummy class provided for users of
+// graphical class browsers.  
+class BlitzMatrixExpressionsBase { };
+
+template<typename P_expr>
+class _bz_MatExpr : public BlitzMatrixExpressionsBase {
+
+public:
+    typedef P_expr T_expr;
+    typedef _bz_typename T_expr::T_numtype T_numtype;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_MatExpr(T_expr a)
+        : iter_(a)
+    { }
+#else
+    _bz_MatExpr(const T_expr& a)
+        : iter_(a)
+    { }
+#endif
+
+    T_numtype operator()(unsigned i, unsigned j) const
+    { return iter_(i,j); }
+
+    unsigned rows(unsigned recommendedRows) const
+    { return iter_.rows(recommendedRows); }
+
+    unsigned cols(unsigned recommendedCols) const
+    { return iter_.cols(recommendedCols); }
+
+private:
+    T_expr iter_;
+};
+
+template<typename P_expr1, typename P_expr2, typename P_op>
+class _bz_MatExprOp : public BlitzMatrixExpressionsBase {
+
+public:
+    typedef P_expr1 T_expr1;
+    typedef P_expr2 T_expr2;
+    typedef _bz_typename T_expr1::T_numtype T_numtype1;
+    typedef _bz_typename T_expr2::T_numtype T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1, T_numtype2) T_numtype;
+    typedef P_op    T_op;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_MatExprOp(T_expr1 a, T_expr2 b)
+        : iter1_(a), iter2_(b)
+    { }
+#else
+    _bz_MatExprOp(const T_expr1& a, const T_expr2& b)
+        : iter1_(a), iter2_(b)
+    { }
+#endif
+
+    T_numtype operator()(unsigned i, unsigned j) const
+    { return T_op::apply(iter1_(i,j), iter2_(i,j)); }
+
+    unsigned rows(unsigned recommendedRows) const
+    {
+        BZPRECONDITION(iter2_.rows(recommendedRows) == 
+            iter1_.rows(recommendedRows));
+        return iter1_.rows(recommendedRows);
+    }
+
+    unsigned cols(unsigned recommendedCols) const
+    {
+        BZPRECONDITION(iter2_.cols(recommendedCols) == 
+            iter1_.cols(recommendedCols));
+        return iter1_.cols(recommendedCols);
+    }
+
+private:
+    T_expr1 iter1_;
+    T_expr2 iter2_;
+};
+
+template<typename P_expr, typename P_unaryOp>
+class _bz_MatExprUnaryOp : public BlitzMatrixExpressionsBase {
+
+public:
+    typedef P_expr T_expr;
+    typedef P_unaryOp T_unaryOp;
+    typedef _bz_typename T_unaryOp::T_numtype T_numtype;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_MatExprUnaryOp(T_expr iter)
+        : iter_(iter)
+    { }
+#else
+    _bz_MatExprUnaryOp(const T_expr& iter)
+        : iter_(iter)
+    { }
+#endif
+
+    T_numtype operator()(unsigned i, unsigned j) const
+    { return T_unaryOp::apply(iter_(i,j)); }
+
+    unsigned rows(unsigned recommendedRows) const
+    { return iter_.rows(recommendedRows); }
+
+    unsigned cols(unsigned recommendedCols) const
+    { return iter_.cols(recommendedCols); }
+
+private:
+    T_expr iter_;    
+};
+
+template<typename P_numtype>
+class _bz_MatExprConstant : public BlitzMatrixExpressionsBase {
+public:
+    typedef P_numtype T_numtype;
+
+    _bz_MatExprConstant(P_numtype value)
+        : value_(value)
+    { }
+
+    T_numtype operator()(unsigned i, unsigned j) const
+    { return value_; }
+
+    unsigned rows(unsigned recommendedRows) const
+    { return recommendedRows; }
+
+    unsigned cols(unsigned recommendedCols) const
+    { return recommendedCols; }
+
+private:
+    T_numtype value_;
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/matref.h>
+#include <blitz/matbops.h>
+#include <blitz/matuops.h>
+
+#endif // BZ_MATEXPR_H
Index: /XMLIO_V2/external/include/blitz/matgen.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matgen.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matgen.h	(revision 73)
@@ -0,0 +1,194 @@
+/***************************************************************************
+ * blitz/matgen.h       Declarations for RowMajor and ColumnMajor matrices
+ *
+ * $Id: matgen.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATGEN_H
+#define BZ_MATGEN_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/matgen.h> must be included via <blitz/mstruct.h>
+#endif // BZ_MSTRUCT_H
+
+BZ_NAMESPACE(blitz)
+
+class GeneralMatrix : public AsymmetricMatrix {
+
+public:
+    GeneralMatrix()
+    { }
+
+    GeneralMatrix(unsigned rows, unsigned cols)
+        : AsymmetricMatrix(rows, cols)
+    {
+    }
+
+    unsigned firstInRow(unsigned i) const
+    { return 0; }
+
+    unsigned lastInRow(unsigned i) const
+    { return cols_ - 1; }
+
+    unsigned firstInCol(unsigned j) const
+    { return 0; }
+
+    unsigned lastInCol(unsigned j) const
+    { return rows_ - 1; }
+
+    unsigned numElements() const
+    { return rows_ * cols_; }
+};
+
+class GeneralIterator {
+public:
+    GeneralIterator(unsigned rows, unsigned cols)
+    {
+        rows_ = rows;
+        cols_ = cols;
+        i_ = 0;
+        j_ = 0;
+        offset_ = 0;
+        good_ = true;
+    }
+
+    unsigned offset() const { return offset_; }
+    operator bool()   const { return good_; }
+    unsigned row()    const { return i_; }
+    unsigned col()    const { return j_; }
+ 
+protected:
+    unsigned rows_, cols_;
+    unsigned offset_;
+    unsigned i_, j_;
+    bool     good_;
+};
+
+class RowMajorIterator : public GeneralIterator {
+public:
+    RowMajorIterator(unsigned rows, unsigned cols)
+        : GeneralIterator(rows, cols)
+    { }
+
+    void operator++()
+    {
+        ++offset_;
+        ++j_;
+        if (j_ == cols_)
+        {
+            j_ = 0;
+            ++i_;
+            if (i_ == rows_)
+                good_ = false;
+        }
+    }
+};
+
+class RowMajor : public GeneralMatrix {
+
+public:
+    typedef RowMajorIterator T_iterator;
+
+    RowMajor()
+    { }
+
+    RowMajor(unsigned rows, unsigned cols)
+        : GeneralMatrix(rows, cols)
+    { }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        return i*cols_+j;
+    }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+};
+
+class ColumnMajorIterator : public GeneralIterator {
+public:
+    ColumnMajorIterator(unsigned rows, unsigned cols)
+        : GeneralIterator(rows, cols)
+    {
+    }
+
+    void operator++()
+    {
+        ++offset_;
+        ++i_;
+        if (i_ == rows_)
+        {
+            i_ = 0;
+            ++j_;
+            if (j_ == cols_)
+                good_ = false;
+        }
+    }
+};
+
+class ColumnMajor : public GeneralMatrix {
+
+public:
+    ColumnMajor()
+    { }
+
+    ColumnMajor(unsigned rows, unsigned cols)
+        : GeneralMatrix(rows, cols)
+    { }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        return j*rows_ + i;
+    }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATGEN_H
+
Index: /XMLIO_V2/external/include/blitz/mathf2.h
===================================================================
--- /XMLIO_V2/external/include/blitz/mathf2.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/mathf2.h	(revision 73)
@@ -0,0 +1,276 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/mathf2.h  Declaration of additional math functions
+ *
+ * $Id: mathf2.h,v 1.5 2004/03/09 21:56:48 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATHF2_H
+#define BZ_MATHF2_H
+
+#ifndef BZ_APPLICS_H
+ #error <blitz/mathf2.h> should be included via <blitz/applics.h>
+#endif
+
+#include <blitz/prettyprint.h>
+
+BZ_NAMESPACE(blitz)
+
+// cexp(z)     Complex exponential
+template<typename P_numtype1>
+class _bz_cexp : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return _bz_exp<T_numtype1>::apply(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cexp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// csqrt(z)    Complex square root
+template<typename P_numtype1>
+class _bz_csqrt : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return _bz_sqrt<T_numtype1>::apply(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "csqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow2        Square
+template<typename P_numtype1>
+class _bz_pow2 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { 
+        return BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow2(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow3        Cube
+template<typename P_numtype1>
+class _bz_pow3 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { 
+        return BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x) *
+          BZ_NO_PROPAGATE(x);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow3(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow4        Fourth power
+template<typename P_numtype1>
+class _bz_pow4 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { 
+        T_numtype t1 = BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x);
+        return BZ_NO_PROPAGATE(t1) * BZ_NO_PROPAGATE(t1);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow4(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow5        Fifth power
+template<typename P_numtype1>
+class _bz_pow5 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    {
+        T_numtype t1 = BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x);
+        return BZ_NO_PROPAGATE(t1) * BZ_NO_PROPAGATE(t1)
+            * BZ_NO_PROPAGATE(t1);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow5(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow6        Sixth power
+template<typename P_numtype1>
+class _bz_pow6 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    {
+        T_numtype t1 = BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x) 
+            * BZ_NO_PROPAGATE(x);
+        return BZ_NO_PROPAGATE(t1) * BZ_NO_PROPAGATE(t1);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow6(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+
+// pow7        Seventh power
+template<typename P_numtype1>
+class _bz_pow7 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    {
+        T_numtype t1 = BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x) 
+            * BZ_NO_PROPAGATE(x);
+        return BZ_NO_PROPAGATE(t1) * BZ_NO_PROPAGATE(t1)
+            * BZ_NO_PROPAGATE(x);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow7(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow8        Eighth power
+template<typename P_numtype1>
+class _bz_pow8 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    {
+        T_numtype t1 = BZ_NO_PROPAGATE(x) * BZ_NO_PROPAGATE(x);
+        T_numtype t2 = BZ_NO_PROPAGATE(t1) * BZ_NO_PROPAGATE(t1);
+        return BZ_NO_PROPAGATE(t2) * BZ_NO_PROPAGATE(t2);
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "pow8(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+/*
+ * These scalar versions of pow2, pow3, ..., pow8 are provided for
+ * convenience.
+ *
+ * NEEDS_WORK -- include BZ_NO_PROPAGATE for these scalar versions.
+ */
+
+// NEEDS_WORK -- make these templates.  Rely on specialization to
+// handle expression template versions.
+
+#define BZ_DECLARE_POW(T)  \
+ inline T pow2(T x) { return x*x; }                  \
+ inline T pow3(T x) { return x*x*x; }                \
+ inline T pow4(T x) { T t1 = x*x; return t1*t1; }    \
+ inline T pow5(T x) { T t1 = x*x; return t1*t1*x; }  \
+ inline T pow6(T x) { T t1 = x*x*x; return t1*t1; }  \
+ inline T pow7(T x) { T t1 = x*x; return t1*t1*t1*x; } \
+ inline T pow8(T x) { T t1 = x*x, t2=t1*t1; return t2*t2; }  
+
+BZ_DECLARE_POW(int)
+BZ_DECLARE_POW(float)
+BZ_DECLARE_POW(double)
+BZ_DECLARE_POW(long double)
+
+#ifdef BZ_HAVE_COMPLEX
+BZ_DECLARE_POW(complex<float>)
+BZ_DECLARE_POW(complex<double>)
+BZ_DECLARE_POW(complex<long double>)
+#endif
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/mathfunc.h
===================================================================
--- /XMLIO_V2/external/include/blitz/mathfunc.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/mathfunc.h	(revision 73)
@@ -0,0 +1,3084 @@
+// Generated: genmathfunc.cpp Jan 28 2005 12:04:32
+
+#ifndef BZ_MATHFUNC_H
+#define BZ_MATHFUNC_H
+
+#ifndef BZ_APPLICS_H
+ #error <blitz/mathfunc.h> should be included via <blitz/applics.h>
+#endif
+
+
+#ifndef BZ_PRETTYPRINT_H
+ #include <blitz/prettyprint.h>
+#endif
+
+#include <cstdlib>
+
+BZ_NAMESPACE(blitz)
+
+// abs(P_numtype1)    Absolute value
+template<typename P_numtype1>
+class _bz_abs : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(abs)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "abs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// abs(long)
+template<>
+class _bz_abs<long> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long T_numtype1;
+    typedef long T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(labs)((long)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "labs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// abs(float)
+template<>
+class _bz_abs<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(fabs)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "fabs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// abs(double)
+template<>
+class _bz_abs<double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef double T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(fabs)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "fabs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// abs(long double)
+template<>
+class _bz_abs<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(fabs)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "fabs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// abs(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_abs<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(abs)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "abs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// abs(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_abs<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(abs)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "abs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// abs(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_abs<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(abs)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "abs(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// acos(P_numtype1)    Inverse cosine
+template<typename P_numtype1>
+class _bz_acos : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(acos)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// acos(float)
+template<>
+class _bz_acos<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(acos)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// acos(long double)
+template<>
+class _bz_acos<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(acos)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// acos(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_acos<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(acos)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// acos(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_acos<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(acos)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// acos(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_acos<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(acos)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// acosh(P_numtype1)    Inverse hyperbolic cosine
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_acosh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(acosh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "acosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// asin(P_numtype1)    Inverse sine
+template<typename P_numtype1>
+class _bz_asin : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(asin)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// asin(float)
+template<>
+class _bz_asin<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(asin)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// asin(long double)
+template<>
+class _bz_asin<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(asin)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// asin(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_asin<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(asin)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// asin(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_asin<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(asin)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// asin(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_asin<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(asin)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// asinh(P_numtype1)    Inverse hyperbolic sine
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_asinh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(asinh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "asinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// arg(P_numtype1)
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<typename P_numtype1>
+class _bz_arg : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return 0; }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "0(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// arg(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_arg<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(arg)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "arg(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// arg(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_arg<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(arg)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "arg(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// arg(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<>
+class _bz_arg<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(arg)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "arg(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// atan(P_numtype1)    Inverse tangent
+template<typename P_numtype1>
+class _bz_atan : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(atan)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// atan(float)
+template<>
+class _bz_atan<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(atan)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// atan(long double)
+template<>
+class _bz_atan<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(atan)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// atan(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_atan<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(atan)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// atan(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_atan<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(atan)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// atan(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_atan<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(atan)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// atanh(P_numtype1)    Inverse hyperbolic tangent
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_atanh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(atanh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "atanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// atan2(P_numtype1, P_numtype2)    Inverse tangent
+template<typename P_numtype1, typename P_numtype2>
+class _bz_atan2 : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(atan2)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "atan2(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// atan2(float, float)
+template<>
+class _bz_atan2<float, float > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype2;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(atan2)((float)x,(float)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "atan2(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// atan2(long double, long double)
+template<>
+class _bz_atan2<long double, long double > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype2;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(atan2)((long double)x,(long double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "atan2(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// _class(P_numtype1)    Classification of float-point value (FP_xxx)
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1>
+class _bz__class : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef int T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(_class)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "_class(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// cbrt(P_numtype1)    Cube root
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_cbrt : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(cbrt)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cbrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// ceil(P_numtype1)    Ceiling
+template<typename P_numtype1>
+class _bz_ceil : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(ceil)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "ceil(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// ceil(float)
+template<>
+class _bz_ceil<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(ceil)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "ceil(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// ceil(long double)
+template<>
+class _bz_ceil<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(ceil)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "ceil(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// conj(P_numtype1)
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<typename P_numtype1>
+class _bz_conj : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(conj)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "conj(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// cos(P_numtype1)    Cosine
+template<typename P_numtype1>
+class _bz_cos : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cos)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cos(float)
+template<>
+class _bz_cos<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cos)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cos(long double)
+template<>
+class _bz_cos<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cos)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cos(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cos<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cos)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// cos(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cos<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cos)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// cos(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cos<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cos)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cos(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// copysign(P_numtype1, P_numtype2)
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_copysign : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(copysign)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "copysign(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// cosh(P_numtype1)    Hyperbolic cosine
+template<typename P_numtype1>
+class _bz_cosh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cosh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cosh(float)
+template<>
+class _bz_cosh<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cosh)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cosh(long double)
+template<>
+class _bz_cosh<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(cosh)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// cosh(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cosh<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cosh)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// cosh(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cosh<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cosh)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// cosh(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_cosh<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(cosh)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "cosh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// drem(P_numtype1, P_numtype2)    Remainder
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_drem : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(drem)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "drem(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// exp(P_numtype1)    Exponential
+template<typename P_numtype1>
+class _bz_exp : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(exp)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// exp(float)
+template<>
+class _bz_exp<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(exp)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// exp(long double)
+template<>
+class _bz_exp<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(exp)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// exp(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_exp<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(exp)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// exp(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_exp<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(exp)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// exp(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_exp<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(exp)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "exp(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// expm1(P_numtype1)    Exp(x)-1
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_expm1 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(expm1)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "expm1(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// erf(P_numtype1)    Error function
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_erf : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(erf)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "erf(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// erfc(P_numtype1)    Complementary error function
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_erfc : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(erfc)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "erfc(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// floor(P_numtype1)    Floor function
+template<typename P_numtype1>
+class _bz_floor : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(floor)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "floor(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// floor(float)
+template<>
+class _bz_floor<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(floor)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "floor(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// floor(long double)
+template<>
+class _bz_floor<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(floor)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "floor(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// fmod(P_numtype1, P_numtype2)    Modulo remainder
+template<typename P_numtype1, typename P_numtype2>
+class _bz_fmod : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(fmod)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "fmod(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// hypot(P_numtype1, P_numtype2)    sqrt(x*x+y*y)
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_hypot : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(hypot)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "hypot(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// ilogb(P_numtype1)    Integer unbiased exponent
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_ilogb : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef int T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(ilogb)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "ilogb(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// blitz_isnan(P_numtype1)    Nonzero if NaNS or NaNQ
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_blitz_isnan : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef int T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    {
+#ifdef BZ_ISNAN_IN_NAMESPACE_STD
+        return BZ_STD_SCOPE(isnan)(x);
+#else
+        return BZ_IEEEMATHFN_SCOPE(isnan)(x);
+#endif
+    }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "blitz_isnan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// itrunc(P_numtype1)    Truncate and convert to integer
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1>
+class _bz_itrunc : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef int T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(itrunc)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "itrunc(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// j0(P_numtype1)    Bessel function first kind, order 0
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_j0 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(j0)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "j0(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// j1(P_numtype1)    Bessel function first kind, order 1
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_j1 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(j1)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "j1(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// lgamma(P_numtype1)    Log absolute gamma
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_lgamma : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(lgamma)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "lgamma(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log(P_numtype1)    Natural logarithm
+template<typename P_numtype1>
+class _bz_log : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log(float)
+template<>
+class _bz_log<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log(long double)
+template<>
+class _bz_log<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_log<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_log<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// log(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_log<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// logb(P_numtype1)    Unbiased exponent (IEEE)
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_logb : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(logb)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "logb(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log1p(P_numtype1)    Compute log(1 + x)
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_log1p : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(log1p)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log1p(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log10(P_numtype1)    Logarithm base 10
+template<typename P_numtype1>
+class _bz_log10 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log10)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log10(float)
+template<>
+class _bz_log10<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log10)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log10(long double)
+template<>
+class _bz_log10<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(log10)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// log10(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_log10<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log10)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log10(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_log10<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log10)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// log10(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH2
+template<>
+class _bz_log10<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(log10)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "log10(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// nearest(P_numtype1)    Nearest floating point integer
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1>
+class _bz_nearest : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(nearest)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "nearest(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// nextafter(P_numtype1, P_numtype2)    Next representable number after x towards y
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_nextafter : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(nextafter)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "nextafter(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+template<typename P_numtype>
+class _bz_negate : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef BZ_SIGNEDTYPE(P_numtype) T_numtype;
+
+    static inline T_numtype apply(T_numtype x)
+    { return -x; }
+
+        template<typename T1>
+        static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format, const T1& a)
+        {
+                str += "-(";
+                       a.prettyPrint(str,format);
+                       str += ")";
+        }
+};
+
+// norm(P_numtype1)
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<typename P_numtype1>
+class _bz_norm : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype1 T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(norm)(x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "norm(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// polar(P_numtype1, P_numtype2)
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<typename P_numtype1, typename P_numtype2>
+class _bz_polar : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef complex<T_numtype1> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_CMATHFN_SCOPE(polar)(x,y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "polar(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// pow(P_numtype1, P_numtype2)    Power
+template<typename P_numtype1, typename P_numtype2>
+class _bz_pow : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(pow)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+#ifndef __PGI
+// pow(float, float)
+template<>
+class _bz_pow<float, float > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype2;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(pow)((float)x,(float)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+#endif
+// pow(long double, long double)
+template<>
+class _bz_pow<long double, long double > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype2;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_MATHFN_SCOPE(pow)((long double)x,(long double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// pow(complex<float>, complex<float>)
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_pow<complex<float>, complex<float> > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float> T_numtype1;
+    typedef complex<float> T_numtype2;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_CMATHFN_SCOPE(pow)((complex<float>)x,(complex<float>)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// pow(complex<double>, complex<double>)
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_pow<complex<double>, complex<double> > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double> T_numtype1;
+    typedef complex<double> T_numtype2;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_CMATHFN_SCOPE(pow)((complex<double>)x,(complex<double>)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// pow(complex<long double>, complex<long double>)
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_pow<complex<long double>, complex<long double> > : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double> T_numtype1;
+    typedef complex<long double> T_numtype2;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_CMATHFN_SCOPE(pow)((complex<long double>)x,(complex<long double>)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "pow(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// remainder(P_numtype1, P_numtype2)    Remainder
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_remainder : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(remainder)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "remainder(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// rint(P_numtype1)    Round to floating point integer
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_rint : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(rint)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "rint(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// rsqrt(P_numtype1)    Reciprocal square root
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1>
+class _bz_rsqrt : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(rsqrt)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "rsqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// scalb(P_numtype1, P_numtype2)    x * (2**y)
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_scalb : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(scalb)((double)x,(double)y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "scalb(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// sin(P_numtype1)    Sine
+template<typename P_numtype1>
+class _bz_sin : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sin)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sin(float)
+template<>
+class _bz_sin<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sin)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sin(long double)
+template<>
+class _bz_sin<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sin)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sin(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sin<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sin)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// sin(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sin<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sin)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// sin(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sin<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sin)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sin(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// sinh(P_numtype1)    Hyperbolic sine
+template<typename P_numtype1>
+class _bz_sinh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sinh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sinh(float)
+template<>
+class _bz_sinh<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sinh)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sinh(long double)
+template<>
+class _bz_sinh<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sinh)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sinh(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sinh<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sinh)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// sinh(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sinh<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sinh)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// sinh(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sinh<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sinh)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sinh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+template<typename P_numtype>
+class _bz_sqr : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype T_numtype;
+
+    static inline T_numtype apply(T_numtype x)
+    { return x*x; }
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqr(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+#ifdef BZ_HAVE_COMPLEX
+// Specialization of _bz_sqr for complex<T>
+template<typename T>
+class _bz_sqr<complex<T> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<T> T_numtype;
+
+    static inline T_numtype apply(T_numtype x)
+    {
+        T r = x.real();  T i = x.imag();
+        return T_numtype(r*r-i*i, 2*r*i);
+    }
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqr(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// sqrt(P_numtype1)    Square root
+template<typename P_numtype1>
+class _bz_sqrt : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sqrt)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sqrt(float)
+template<>
+class _bz_sqrt<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sqrt)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sqrt(long double)
+template<>
+class _bz_sqrt<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(sqrt)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// sqrt(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sqrt<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sqrt)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// sqrt(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sqrt<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sqrt)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// sqrt(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_sqrt<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(sqrt)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "sqrt(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// tan(P_numtype1)    Tangent
+template<typename P_numtype1>
+class _bz_tan : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tan)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tan(float)
+template<>
+class _bz_tan<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tan)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tan(long double)
+template<>
+class _bz_tan<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tan)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tan(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tan<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tan)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// tan(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tan<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tan)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// tan(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tan<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tan)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tan(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// tanh(P_numtype1)    Hyperbolic tangent
+template<typename P_numtype1>
+class _bz_tanh : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tanh)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tanh(float)
+template<>
+class _bz_tanh<float> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef float T_numtype1;
+    typedef float T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tanh)((float)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tanh(long double)
+template<>
+class _bz_tanh<long double> : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef long double T_numtype1;
+    typedef long double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_MATHFN_SCOPE(tanh)((long double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+
+// tanh(complex<float> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tanh<complex<float> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<float>  T_numtype1;
+    typedef complex<float> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tanh)((complex<float> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// tanh(complex<double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tanh<complex<double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<double>  T_numtype1;
+    typedef complex<double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tanh)((complex<double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#ifndef __PGI
+// tanh(complex<long double> )
+#ifdef BZ_HAVE_COMPLEX_MATH1
+template<>
+class _bz_tanh<complex<long double> > : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef complex<long double>  T_numtype1;
+    typedef complex<long double> T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_CMATHFN_SCOPE(tanh)((complex<long double> )x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "tanh(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+#endif
+// uitrunc(P_numtype1)    Truncate and convert to unsigned
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1>
+class _bz_uitrunc : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef unsigned T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(uitrunc)((unsigned)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "uitrunc(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// unordered(P_numtype1, P_numtype2)    True if a comparison of x and y would be unordered
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<typename P_numtype1, typename P_numtype2>
+class _bz_unordered : public TwoOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef P_numtype2 T_numtype2;
+    typedef int T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x, T_numtype2 y)
+    { return BZ_IEEEMATHFN_SCOPE(unordered)(x,y); }
+
+    template<typename T1, typename T2>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a, const T2& b)
+    {
+        str += "unordered(";
+        a.prettyPrint(str,format);
+        str += ",";
+        b.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// y0(P_numtype1)    Bessel function of the second kind, order zero
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_y0 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(y0)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "y0(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+// y1(P_numtype1)    Bessel function of the second kind, order one
+#ifdef BZ_HAVE_IEEE_MATH
+template<typename P_numtype1>
+class _bz_y1 : public OneOperandApplicativeTemplatesBase {
+public:
+    typedef P_numtype1 T_numtype1;
+    typedef double T_numtype;
+
+    static inline T_numtype apply(T_numtype1 x)
+    { return BZ_IEEEMATHFN_SCOPE(y1)((double)x); }
+
+    template<typename T1>
+    static void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat& format,
+        const T1& a)
+    {
+        str += "y1(";
+        a.prettyPrint(str,format);
+        str += ")";
+    }
+};
+#endif
+
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATHFUNC_H
Index: /XMLIO_V2/external/include/blitz/matltri.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matltri.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matltri.h	(revision 73)
@@ -0,0 +1,177 @@
+/***************************************************************************
+ * blitz/matltri.h      Declarations for LowerTriangular matrices
+ *
+ * $Id: matltri.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_MATLTRI_H
+#define BZ_MATLTRI_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/matltri.h> must be included via <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Lower triangular, row major ordering
+// [ 0 . . . ]
+// [ 1 2 . . ]
+// [ 3 4 5 . ]
+// [ 6 7 8 9 ]
+
+class LowerTriangularIterator {
+public:
+    LowerTriangularIterator(unsigned rows, unsigned cols)
+    {
+        BZPRECONDITION(rows == cols);
+        size_ = rows;
+        good_ = true;
+        offset_ = 0;
+        i_ = 0;
+        j_ = 0;
+    }
+   
+    operator bool() const { return good_; }
+
+    void operator++()
+    {
+        BZPRECONDITION(good_);
+        ++offset_;
+        ++j_;
+        if (j_ > i_)
+        {
+            j_ = 0;
+            ++i_;
+            if (i_ == size_)
+                good_ = false;
+        }
+    }
+
+    unsigned row() const
+    { return i_; }
+
+    unsigned col() const
+    { return j_; }
+
+    unsigned offset() const
+    { return offset_; }
+
+protected:
+    unsigned size_;
+    bool good_;
+    unsigned offset_;
+    unsigned i_, j_;
+};
+
+class LowerTriangular : public MatrixStructure {
+
+public:
+    typedef LowerTriangularIterator T_iterator;
+
+    LowerTriangular()
+        : size_(0)
+    { }
+
+    LowerTriangular(unsigned size)
+        : size_(size)
+    { }
+
+    LowerTriangular(unsigned rows, unsigned cols)
+        : size_(rows)
+    {
+        BZPRECONDITION(rows == cols);
+    }
+
+    unsigned columns() const
+    { return size_; }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        BZPRECONDITION(i >= j);
+        return i*(i+1)/2 + j;
+    }
+
+    unsigned firstInRow(unsigned i) const
+    { return 0; }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        if (i >= j)
+            return data[coordToOffset(i,j)];
+        else
+            return ZeroElement<T_numtype>::zero();
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        if (i >= j)
+            return data[coordToOffset(i,j)];
+        else
+            return ZeroElement<T_numtype>::zero();
+    }
+
+    unsigned lastInRow(unsigned i) const
+    { return i; }
+
+    unsigned firstInCol(unsigned j) const
+    { return j; }
+
+    unsigned lastInCol(unsigned j) const
+    { return size_ - 1; }
+
+    bool inRange(unsigned i, unsigned j) const
+    {
+        return (i < size_) && (j < size_);
+    }
+
+    unsigned numElements() const
+    { return size_ * (size_ + 1) / 2; }
+
+    unsigned rows() const
+    { return size_; }
+
+    void resize(unsigned size)
+    {
+        size_ = size;
+    }
+
+    void resize(unsigned rows, unsigned cols)
+    {
+        BZPRECONDITION(rows == cols);
+        size_  = rows;
+    }
+
+private:
+    unsigned size_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATLTRI_H
+
Index: /XMLIO_V2/external/include/blitz/matref.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matref.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matref.h	(revision 73)
@@ -0,0 +1,63 @@
+/***************************************************************************
+ * blitz/matref.h      Declaration of the _bz_MatrixRef<P_numtype, P_structure>
+ *                     class.
+ *
+ * $Id: matref.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATREF_H
+#define BZ_MATREF_H
+
+#ifndef BZ_MATEXPR_H
+ #error <blitz/matref.h> must be included via <blitz/matexpr.h>
+#endif // BZ_MATEXPR_H
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype, typename P_structure>
+class _bz_MatrixRef {
+
+public:
+    typedef P_numtype T_numtype;
+
+    _bz_MatrixRef(const Matrix<P_numtype, P_structure>& m)
+        : matrix_(&m)
+    { }
+
+    T_numtype operator()(unsigned i, unsigned j) const
+    { return (*matrix_)(i,j); }
+
+    unsigned rows(unsigned) const
+    { return matrix_->rows(); }
+
+    unsigned cols(unsigned) const
+    { return matrix_->cols(); }
+
+private:
+    _bz_MatrixRef() { } 
+
+    const Matrix<P_numtype, P_structure>* matrix_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATREF_H
Index: /XMLIO_V2/external/include/blitz/matrix.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/matrix.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matrix.cc	(revision 73)
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_MATRIX_CC
+#define BZ_MATRIX_CC
+
+#ifndef BZ_MATRIX_H
+ #include <blitz/matrix.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Matrix expression operand
+template<typename P_numtype, typename P_structure> template<typename P_expr>
+Matrix<P_numtype, P_structure>& 
+Matrix<P_numtype, P_structure>::operator=(_bz_MatExpr<P_expr> expr)
+{
+    // Check for compatible structures.
+
+    // Fast evaluation (compatible structures)
+    // (not implemented)
+
+    // Slow evaluation
+    _bz_typename P_structure::T_iterator iter(rows(), cols());
+    while (iter)
+    {
+        data_[iter.offset()] = expr(iter.row(), iter.col());
+        ++iter;
+    }
+
+    return *this;
+}
+
+template<typename P_numtype, typename P_structure>
+ostream& operator<<(ostream& os, const Matrix<P_numtype, P_structure>& matrix)
+{
+    os << "[ ";
+    for (int i=0; i < matrix.rows(); ++i)
+    {
+        for (int j=0; j < matrix.columns(); ++j)
+        {
+            os << setw(10) << matrix(i,j);
+            if ((!((j+1)%7)) && (j < matrix.cols()-1))
+                os << endl << "         ...";
+        }
+        if (i != matrix.rows() - 1)
+            os << endl  << "  ";
+    }
+    os << " ]";
+    return os;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATRIX_CC
Index: /XMLIO_V2/external/include/blitz/matrix.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matrix.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matrix.h	(revision 73)
@@ -0,0 +1,213 @@
+/***************************************************************************
+ * blitz/matrix.h      Declaration of the Matrix<T_type, T_structure> class
+ *
+ * $Id: matrix.h,v 1.6 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATRIX_H
+#define BZ_MATRIX_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_MEMBLOCK_H
+ #include <blitz/memblock.h>
+#endif
+
+#ifndef BZ_MSTRUCT_H
+ #include <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Forward declarations
+template<typename P_numtype, typename P_structure>
+class _bz_MatrixRef;
+
+template<typename P_expr>
+class _bz_MatExpr;
+
+// Declaration of class Matrix
+template<typename P_numtype, typename P_structure BZ_TEMPLATE_DEFAULT(RowMajor)>
+class Matrix : protected MemoryBlockReference<P_numtype> {
+
+private:
+    typedef MemoryBlockReference<P_numtype> T_base;
+    using T_base::data_;
+
+public:
+
+    //////////////////////////////////////////////
+    // Public Types
+    //////////////////////////////////////////////
+
+    typedef P_numtype        T_numtype;
+    typedef P_structure      T_structure;
+    typedef Matrix<P_numtype, P_structure>   T_matrix;
+
+    //////////////////////////////////////////////
+    // Constructors                             //
+    //////////////////////////////////////////////
+
+    Matrix()
+    { }
+
+    Matrix(int rows, int cols, T_structure structure = T_structure())
+        : structure_(structure) 
+    {
+        structure_.resize(rows, cols);
+        MemoryBlockReference<T_numtype>::newBlock(structure_.numElements());
+    }
+
+    // Matrix(int rows, int cols, T_numtype initValue,
+    //    T_structure structure = T_structure(rows, cols));
+    // Matrix(int rows, int cols, Random);
+    // Matrix(int rows, int cols, matrix-expression);
+    // Matrix(int rows, int cols, T_numtype* data, int rowStride, int colStride);
+    // explicit Matrix(Vector<T_numtype>& matrix);
+    // explicit Matrix(unsigned length);
+
+    // Create a vector view of an already allocated block of memory.
+    // Note that the memory will not be freed when this vector is
+    // destroyed.
+    // Matrix(unsigned length, T_numtype* data, int stride = 1);
+
+    //////////////////////////////////////////////
+    // Member functions
+    //////////////////////////////////////////////
+
+    //T_iterator      begin()  const;
+    //T_constIterator begin()  const;
+    //T_vector        copy()   const;
+    //T_iterator      end()    const;
+    //T_constIterator end()    const;
+
+    unsigned        cols()        const
+    { return structure_.columns(); }
+
+    unsigned        columns()     const
+    { return structure_.columns(); }
+
+    void            makeUnique()  const;
+
+    unsigned        numElements() const
+    { return structure_.numElements(); }
+
+    void            reference(T_matrix&);
+
+    void            resize(unsigned rows, unsigned cols)
+    {
+        structure_.resize(rows, cols);
+        MemoryBlockReference<T_numtype>::newBlock(structure_.numElements());
+    }
+
+//    void            resizeAndPreserve(unsigned newLength);
+
+    unsigned        rows()   const
+    { return structure_.rows(); }
+
+    _bz_MatrixRef<T_numtype, T_structure> _bz_getRef() const
+    { return _bz_MatrixRef<T_numtype, T_structure>(*this); }
+
+    //////////////////////////////////////////////
+    // Subscripting operators
+    //////////////////////////////////////////////
+
+    T_numtype           operator()(unsigned i, unsigned j) const
+    {
+        return structure_.get(data_, i, j);
+    }
+
+    T_numtype& restrict operator()(unsigned i, unsigned j)
+    {
+        return structure_.get(data_, i, j);
+    }
+
+    // T_matrix      operator()(Range,Range);
+
+    // T_matrixIndirect operator()(Vector<int>,Vector<int>);
+    // T_matrixIndirect operator()(integer-placeholder-expression, Range);
+    // T_matrix         operator()(difference-equation-expression)
+
+    //////////////////////////////////////////////
+    // Assignment operators
+    //////////////////////////////////////////////
+
+    // Scalar operand
+    T_matrix& operator=(T_numtype);
+    T_matrix& operator+=(T_numtype);
+    T_matrix& operator-=(T_numtype);
+    T_matrix& operator*=(T_numtype);
+    T_matrix& operator/=(T_numtype);
+
+    // Matrix operand
+
+    template<typename P_numtype2, typename P_structure2> 
+    T_matrix& operator=(const Matrix<P_numtype2, P_structure2> &);
+    template<typename P_numtype2, typename P_structure2> 
+    T_matrix& operator+=(const Matrix<P_numtype2, P_structure2>&);
+    template<typename P_numtype2, typename P_structure2> 
+    T_matrix& operator-=(const Matrix<P_numtype2, P_structure2> &);
+    template<typename P_numtype2, typename P_structure2> 
+    T_matrix& operator*=(const Matrix<P_numtype2, P_structure2> &);
+    template<typename P_numtype2, typename P_structure2> 
+    T_matrix& operator/=(const Matrix<P_numtype2, P_structure2> &);
+
+    // Matrix expression operand
+    template<typename P_expr>
+    T_matrix& operator=(_bz_MatExpr<P_expr>);
+
+    // Integer placeholder expression operand
+    // MatrixPick operand
+
+    //////////////////////////////////////////////
+    // Unary operators
+    //////////////////////////////////////////////
+
+    T_matrix& operator++();
+    void operator++(int);
+    T_matrix& operator--();
+    void operator--(int);
+    
+private:
+    T_structure structure_;
+};
+
+template<typename P_numtype, typename P_structure>
+ostream& operator<<(ostream& os, const Matrix<P_numtype, P_structure>& matrix);
+
+// Global operators
+// +,-,*,/ with all possible combinations of:
+//    - scalar
+//    - matrix
+//    - matrix pick
+//    - matrix expression
+// Pointwise Math functions: sin, cos, etc.
+// Global functions
+
+BZ_NAMESPACE_END
+
+#include <blitz/matrix.cc>
+#include <blitz/matexpr.h>
+
+#endif // BZ_MATRIX_H
Index: /XMLIO_V2/external/include/blitz/matsymm.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matsymm.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matsymm.h	(revision 73)
@@ -0,0 +1,171 @@
+/***************************************************************************
+ * blitz/matsymm.h      Declarations for Symmetric matrices
+ *
+ * $Id: matsymm.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATSYMM_H
+#define BZ_MATSYMM_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/matsymm.h> must be included via <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Symmetric, lower triangular row major ordering
+// [ 0 1 3 6 ]
+// [ 1 2 4 7 ]
+// [ 3 4 5 8 ]
+// [ 6 7 8 9 ]
+
+class SymmetricIterator {
+public:
+    SymmetricIterator(unsigned rows, unsigned cols)
+    {
+        BZPRECONDITION(rows == cols);
+        size_ = rows;
+        good_ = true;
+        offset_ = 0;
+        i_ = 0;
+        j_ = 0;
+    }
+   
+    operator bool() const { return good_; }
+
+    void operator++()
+    {
+        BZPRECONDITION(good_);
+        ++offset_;
+        ++j_;
+        if (j_ > i_)
+        {
+            j_ = 0;
+            ++i_;
+            if (i_ == size_)
+                good_ = false;
+        }
+    }
+
+    unsigned row() const
+    { return i_; }
+
+    unsigned col() const
+    { return j_; }
+
+    unsigned offset() const
+    { return offset_; }
+
+protected:
+    unsigned size_;
+    bool     good_;
+    unsigned offset_;
+    unsigned i_, j_;
+};
+
+class Symmetric : public MatrixStructure {
+
+public:
+    typedef SymmetricIterator T_iterator;
+
+    Symmetric()
+        : size_(0)
+    { }
+
+    Symmetric(unsigned size)
+        : size_(size)
+    { }
+
+    Symmetric(unsigned rows, unsigned cols)
+        : size_(rows)
+    {
+        BZPRECONDITION(rows == cols);
+    }
+
+    unsigned columns() const
+    { return size_; }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        if (i >= j)
+            return i*(i+1)/2 + j;
+        else
+            return j*(j+1)/2 + i;
+    }
+
+    unsigned firstInRow(unsigned i) const
+    { return 0; }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    unsigned lastInRow(unsigned i) const
+    { return i; }
+
+    unsigned firstInCol(unsigned j) const
+    { return j; }
+
+    unsigned lastInCol(unsigned j) const
+    { return size_ - 1; }
+
+    bool inRange(unsigned i, unsigned j) const {
+        return (i < size_) && (j < size_);
+    }
+
+    unsigned numElements() const
+    { return size_ * (size_ + 1) / 2; }
+
+    unsigned rows() const
+    { return size_; }
+
+    void resize(unsigned size)
+    {
+        size_ = size;
+    }
+
+    void resize(unsigned rows, unsigned cols)
+    {
+        BZPRECONDITION(rows == cols);
+        size_  = rows;
+    }
+
+private:
+    unsigned size_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATSYMM_H
+
Index: /XMLIO_V2/external/include/blitz/mattoep.h
===================================================================
--- /XMLIO_V2/external/include/blitz/mattoep.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/mattoep.h	(revision 73)
@@ -0,0 +1,144 @@
+/***************************************************************************
+ * blitz/mattoep.h      Declarations for Toeplitz matrices
+ *
+ * $Id: mattoep.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATTOEP_H
+#define BZ_MATTOEP_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/mattoep.h> must be included via <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Toeplitz matrix
+// [ 0 1 2 3 ]
+// [ 1 2 3 4 ]
+// [ 2 3 4 5 ]
+// [ 3 4 5 6 ]
+
+class ToeplitzIterator {
+public:
+    ToeplitzIterator(unsigned rows, unsigned cols)
+    {
+        rows_ = rows;
+        cols_ = cols;
+        i_ = 0;
+        j_ = 0;
+        good_ = true;
+        offset_ = 0;
+    }
+
+    operator bool() const { return good_; }
+
+    void operator++()
+    {
+        ++offset_;
+        if (i_ < rows_ - 1)
+            ++i_;
+        else if (j_ < cols_ - 1)
+            ++j_;
+        else
+            good_ = false;
+    }
+
+    unsigned row() const
+    { return i_; }
+
+    unsigned col() const
+    { return j_; }
+
+    unsigned offset() const
+    { return offset_; }
+
+protected:
+    unsigned offset_;
+    unsigned i_, j_;
+    unsigned rows_, cols_;
+    bool     good_;
+};
+
+class Toeplitz : public GeneralMatrix {
+
+public:
+    typedef ToeplitzIterator T_iterator;
+
+    Toeplitz()
+        : rows_(0), cols_(0)
+    { }
+
+    Toeplitz(unsigned rows, unsigned cols)
+        : rows_(rows), cols_(cols)
+    { }
+
+    unsigned columns() const
+    { return cols_; }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return i + j;
+    }
+
+    unsigned firstInRow(unsigned i) const
+    { return 0; }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        return data[coordToOffset(i,j)];
+    }
+
+    unsigned lastInRow(const unsigned)  const { return cols_ - 1; }
+    unsigned firstInCol(const unsigned) const { return 0; }
+    unsigned lastInCol(const unsigned)  const { return rows_ - 1; }
+
+    bool inRange(const unsigned i,const unsigned j) const { return (i<rows_) && (j<cols_); }
+
+    unsigned numElements() const { return rows_ + cols_ - 1; }
+
+    unsigned rows() const { return rows_; }
+
+    void resize(const unsigned rows,const unsigned cols) {
+        rows_ = rows;
+        cols_ = cols;
+    }
+
+private:
+    unsigned rows_, cols_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATSYMM_H
+
Index: /XMLIO_V2/external/include/blitz/matuops.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matuops.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matuops.h	(revision 73)
@@ -0,0 +1,4164 @@
+// Generated source file.  Do not edit.
+// Created by: genmatuops.cpp Dec 10 2003 17:58:05
+
+#ifndef BZ_MATUOPS_H
+#define BZ_MATUOPS_H
+
+BZ_NAMESPACE(blitz)
+
+#ifndef BZ_MATEXPR_H
+ #error <blitz/matuops.h> must be included via <blitz/matexpr.h>
+#endif
+
+/****************************************************************************
+ * abs
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_abs<P_numtype1> > >
+abs(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_abs<typename P_expr1::T_numtype> > >
+abs(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_abs<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * acos
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_acos<P_numtype1> > >
+acos(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_acos<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_acos<typename P_expr1::T_numtype> > >
+acos(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_acos<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * acosh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_acosh<P_numtype1> > >
+acosh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_acosh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_acosh<typename P_expr1::T_numtype> > >
+acosh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_acosh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * asin
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_asin<P_numtype1> > >
+asin(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_asin<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_asin<typename P_expr1::T_numtype> > >
+asin(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_asin<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * asinh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_asinh<P_numtype1> > >
+asinh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_asinh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_asinh<typename P_expr1::T_numtype> > >
+asinh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_asinh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * atan
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_atan<P_numtype1> > >
+atan(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_atan<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_atan<typename P_expr1::T_numtype> > >
+atan(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_atan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * atan2
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_atan2<P_numtype1,float> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_atan2<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_atan2<P_numtype1,double> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_atan2<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_atan2<P_numtype1,long double> > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_atan2<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_atan2<P_numtype1,complex<T2> > > >
+atan2(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
+atan2(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+atan2(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_atan2<typename P_expr1::T_numtype,int> > >
+atan2(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_atan2<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_atan2<typename P_expr1::T_numtype,float> > >
+atan2(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_atan2<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_atan2<typename P_expr1::T_numtype,double> > >
+atan2(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_atan2<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_atan2<typename P_expr1::T_numtype,long double> > >
+atan2(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_atan2<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > >
+atan2(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<int,typename P_expr2::T_numtype> > >
+atan2(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<float,P_numtype2> > >
+atan2(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<float,typename P_expr2::T_numtype> > >
+atan2(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<double,P_numtype2> > >
+atan2(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<double,typename P_expr2::T_numtype> > >
+atan2(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<long double,P_numtype2> > >
+atan2(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_atan2<long double,typename P_expr2::T_numtype> > >
+atan2(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_atan2<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_atan2<complex<T1> ,P_numtype2> > >
+atan2(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > >
+atan2(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+
+/****************************************************************************
+ * atanh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_atanh<P_numtype1> > >
+atanh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_atanh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_atanh<typename P_expr1::T_numtype> > >
+atanh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_atanh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * _class
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz__class<P_numtype1> > >
+_class(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz__class<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz__class<typename P_expr1::T_numtype> > >
+_class(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz__class<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * cbrt
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_cbrt<P_numtype1> > >
+cbrt(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_cbrt<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_cbrt<typename P_expr1::T_numtype> > >
+cbrt(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_cbrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * ceil
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_ceil<P_numtype1> > >
+ceil(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_ceil<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_ceil<typename P_expr1::T_numtype> > >
+ceil(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_ceil<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * copysign
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_copysign<P_numtype1,float> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_copysign<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_copysign<P_numtype1,double> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_copysign<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_copysign<P_numtype1,long double> > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_copysign<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_copysign<P_numtype1,complex<T2> > > >
+copysign(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
+copysign(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+copysign(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_copysign<typename P_expr1::T_numtype,int> > >
+copysign(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_copysign<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_copysign<typename P_expr1::T_numtype,float> > >
+copysign(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_copysign<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_copysign<typename P_expr1::T_numtype,double> > >
+copysign(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_copysign<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_copysign<typename P_expr1::T_numtype,long double> > >
+copysign(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_copysign<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > >
+copysign(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<int,typename P_expr2::T_numtype> > >
+copysign(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<float,P_numtype2> > >
+copysign(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<float,typename P_expr2::T_numtype> > >
+copysign(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<double,P_numtype2> > >
+copysign(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<double,typename P_expr2::T_numtype> > >
+copysign(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<long double,P_numtype2> > >
+copysign(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_copysign<long double,typename P_expr2::T_numtype> > >
+copysign(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_copysign<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_copysign<complex<T1> ,P_numtype2> > >
+copysign(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > >
+copysign(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * cos
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_cos<P_numtype1> > >
+cos(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_cos<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_cos<typename P_expr1::T_numtype> > >
+cos(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_cos<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * cosh
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_cosh<P_numtype1> > >
+cosh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_cosh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_cosh<typename P_expr1::T_numtype> > >
+cosh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_cosh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * drem
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_drem<P_numtype1,int> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_drem<P_numtype1,float> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_drem<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_drem<P_numtype1,double> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_drem<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_drem<P_numtype1,long double> > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_drem<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_drem<P_numtype1,complex<T2> > > >
+drem(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_drem<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
+drem(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+drem(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_drem<typename P_expr1::T_numtype,int> > >
+drem(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_drem<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_drem<typename P_expr1::T_numtype,float> > >
+drem(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_drem<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_drem<typename P_expr1::T_numtype,double> > >
+drem(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_drem<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_drem<typename P_expr1::T_numtype,long double> > >
+drem(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_drem<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_drem<typename P_expr1::T_numtype,complex<T2> > > >
+drem(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_drem<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<int,P_numtype2> > >
+drem(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_drem<int,typename P_expr2::T_numtype> > >
+drem(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_drem<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<float,P_numtype2> > >
+drem(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_drem<float,typename P_expr2::T_numtype> > >
+drem(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_drem<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<double,P_numtype2> > >
+drem(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_drem<double,typename P_expr2::T_numtype> > >
+drem(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_drem<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<long double,P_numtype2> > >
+drem(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_drem<long double,typename P_expr2::T_numtype> > >
+drem(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_drem<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_drem<complex<T1> ,P_numtype2> > >
+drem(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > >
+drem(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * exp
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_exp<P_numtype1> > >
+exp(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_exp<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_exp<typename P_expr1::T_numtype> > >
+exp(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_exp<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * expm1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_expm1<P_numtype1> > >
+expm1(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_expm1<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_expm1<typename P_expr1::T_numtype> > >
+expm1(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_expm1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * erf
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_erf<P_numtype1> > >
+erf(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_erf<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_erf<typename P_expr1::T_numtype> > >
+erf(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_erf<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * erfc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_erfc<P_numtype1> > >
+erfc(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_erfc<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_erfc<typename P_expr1::T_numtype> > >
+erfc(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_erfc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * fabs
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_abs<P_numtype1> > >
+fabs(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_abs<typename P_expr1::T_numtype> > >
+fabs(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_abs<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * floor
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_floor<P_numtype1> > >
+floor(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_floor<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_floor<typename P_expr1::T_numtype> > >
+floor(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_floor<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * fmod
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_fmod<P_numtype1,float> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_fmod<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_fmod<P_numtype1,double> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_fmod<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_fmod<P_numtype1,long double> > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_fmod<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_fmod<P_numtype1,complex<T2> > > >
+fmod(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
+fmod(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+fmod(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_fmod<typename P_expr1::T_numtype,int> > >
+fmod(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_fmod<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_fmod<typename P_expr1::T_numtype,float> > >
+fmod(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_fmod<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_fmod<typename P_expr1::T_numtype,double> > >
+fmod(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_fmod<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_fmod<typename P_expr1::T_numtype,long double> > >
+fmod(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_fmod<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > >
+fmod(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<int,typename P_expr2::T_numtype> > >
+fmod(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<float,P_numtype2> > >
+fmod(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<float,typename P_expr2::T_numtype> > >
+fmod(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<double,P_numtype2> > >
+fmod(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<double,typename P_expr2::T_numtype> > >
+fmod(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<long double,P_numtype2> > >
+fmod(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_fmod<long double,typename P_expr2::T_numtype> > >
+fmod(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_fmod<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_fmod<complex<T1> ,P_numtype2> > >
+fmod(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > >
+fmod(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+
+/****************************************************************************
+ * hypot
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_hypot<P_numtype1,float> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_hypot<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_hypot<P_numtype1,double> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_hypot<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_hypot<P_numtype1,long double> > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_hypot<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_hypot<P_numtype1,complex<T2> > > >
+hypot(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
+hypot(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+hypot(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_hypot<typename P_expr1::T_numtype,int> > >
+hypot(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_hypot<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_hypot<typename P_expr1::T_numtype,float> > >
+hypot(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_hypot<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_hypot<typename P_expr1::T_numtype,double> > >
+hypot(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_hypot<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_hypot<typename P_expr1::T_numtype,long double> > >
+hypot(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_hypot<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > >
+hypot(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<int,typename P_expr2::T_numtype> > >
+hypot(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<float,P_numtype2> > >
+hypot(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<float,typename P_expr2::T_numtype> > >
+hypot(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<double,P_numtype2> > >
+hypot(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<double,typename P_expr2::T_numtype> > >
+hypot(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<long double,P_numtype2> > >
+hypot(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_hypot<long double,typename P_expr2::T_numtype> > >
+hypot(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_hypot<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_hypot<complex<T1> ,P_numtype2> > >
+hypot(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > >
+hypot(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * ilogb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_ilogb<P_numtype1> > >
+ilogb(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_ilogb<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_ilogb<typename P_expr1::T_numtype> > >
+ilogb(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_ilogb<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * blitz_isnan
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_blitz_isnan<P_numtype1> > >
+blitz_isnan(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_blitz_isnan<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_blitz_isnan<typename P_expr1::T_numtype> > >
+blitz_isnan(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_blitz_isnan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * itrunc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_itrunc<P_numtype1> > >
+itrunc(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_itrunc<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_itrunc<typename P_expr1::T_numtype> > >
+itrunc(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_itrunc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * j0
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_j0<P_numtype1> > >
+j0(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_j0<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_j0<typename P_expr1::T_numtype> > >
+j0(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_j0<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * j1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_j1<P_numtype1> > >
+j1(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_j1<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_j1<typename P_expr1::T_numtype> > >
+j1(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_j1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * lgamma
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_lgamma<P_numtype1> > >
+lgamma(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_lgamma<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_lgamma<typename P_expr1::T_numtype> > >
+lgamma(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_lgamma<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * log
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_log<P_numtype1> > >
+log(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_log<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_log<typename P_expr1::T_numtype> > >
+log(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_log<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * logb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_logb<P_numtype1> > >
+logb(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_logb<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_logb<typename P_expr1::T_numtype> > >
+logb(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_logb<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * log1p
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_log1p<P_numtype1> > >
+log1p(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_log1p<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_log1p<typename P_expr1::T_numtype> > >
+log1p(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_log1p<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * log10
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_log10<P_numtype1> > >
+log10(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_log10<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_log10<typename P_expr1::T_numtype> > >
+log10(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_log10<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * nearest
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_nearest<P_numtype1> > >
+nearest(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_nearest<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_nearest<typename P_expr1::T_numtype> > >
+nearest(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_nearest<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * nextafter
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_nextafter<P_numtype1,float> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_nextafter<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_nextafter<P_numtype1,double> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_nextafter<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_nextafter<P_numtype1,long double> > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_nextafter<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_nextafter<P_numtype1,complex<T2> > > >
+nextafter(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
+nextafter(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+nextafter(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_nextafter<typename P_expr1::T_numtype,int> > >
+nextafter(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_nextafter<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_nextafter<typename P_expr1::T_numtype,float> > >
+nextafter(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_nextafter<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_nextafter<typename P_expr1::T_numtype,double> > >
+nextafter(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_nextafter<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_nextafter<typename P_expr1::T_numtype,long double> > >
+nextafter(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_nextafter<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > >
+nextafter(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<int,typename P_expr2::T_numtype> > >
+nextafter(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<float,P_numtype2> > >
+nextafter(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<float,typename P_expr2::T_numtype> > >
+nextafter(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<double,P_numtype2> > >
+nextafter(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<double,typename P_expr2::T_numtype> > >
+nextafter(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<long double,P_numtype2> > >
+nextafter(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_nextafter<long double,typename P_expr2::T_numtype> > >
+nextafter(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_nextafter<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_nextafter<complex<T1> ,P_numtype2> > >
+nextafter(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > >
+nextafter(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * pow
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_pow<P_numtype1,int> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_pow<P_numtype1,float> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_pow<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_pow<P_numtype1,double> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_pow<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_pow<P_numtype1,long double> > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_pow<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_pow<P_numtype1,complex<T2> > > >
+pow(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_pow<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
+pow(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+pow(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_pow<typename P_expr1::T_numtype,int> > >
+pow(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_pow<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_pow<typename P_expr1::T_numtype,float> > >
+pow(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_pow<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_pow<typename P_expr1::T_numtype,double> > >
+pow(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_pow<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_pow<typename P_expr1::T_numtype,long double> > >
+pow(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_pow<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_pow<typename P_expr1::T_numtype,complex<T2> > > >
+pow(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_pow<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<int,P_numtype2> > >
+pow(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_pow<int,typename P_expr2::T_numtype> > >
+pow(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_pow<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<float,P_numtype2> > >
+pow(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_pow<float,typename P_expr2::T_numtype> > >
+pow(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_pow<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<double,P_numtype2> > >
+pow(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_pow<double,typename P_expr2::T_numtype> > >
+pow(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_pow<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<long double,P_numtype2> > >
+pow(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_pow<long double,typename P_expr2::T_numtype> > >
+pow(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_pow<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_pow<complex<T1> ,P_numtype2> > >
+pow(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > >
+pow(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+
+/****************************************************************************
+ * remainder
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_remainder<P_numtype1,float> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_remainder<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_remainder<P_numtype1,double> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_remainder<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_remainder<P_numtype1,long double> > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_remainder<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_remainder<P_numtype1,complex<T2> > > >
+remainder(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
+remainder(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+remainder(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_remainder<typename P_expr1::T_numtype,int> > >
+remainder(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_remainder<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_remainder<typename P_expr1::T_numtype,float> > >
+remainder(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_remainder<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_remainder<typename P_expr1::T_numtype,double> > >
+remainder(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_remainder<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_remainder<typename P_expr1::T_numtype,long double> > >
+remainder(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_remainder<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > >
+remainder(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<int,typename P_expr2::T_numtype> > >
+remainder(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<float,P_numtype2> > >
+remainder(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<float,typename P_expr2::T_numtype> > >
+remainder(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<double,P_numtype2> > >
+remainder(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<double,typename P_expr2::T_numtype> > >
+remainder(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<long double,P_numtype2> > >
+remainder(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_remainder<long double,typename P_expr2::T_numtype> > >
+remainder(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_remainder<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_remainder<complex<T1> ,P_numtype2> > >
+remainder(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > >
+remainder(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * rint
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_rint<P_numtype1> > >
+rint(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_rint<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_rint<typename P_expr1::T_numtype> > >
+rint(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_rint<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * rsqrt
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_rsqrt<P_numtype1> > >
+rsqrt(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_rsqrt<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_rsqrt<typename P_expr1::T_numtype> > >
+rsqrt(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_rsqrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * scalb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_scalb<P_numtype1,float> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_scalb<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_scalb<P_numtype1,double> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_scalb<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_scalb<P_numtype1,long double> > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_scalb<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_scalb<P_numtype1,complex<T2> > > >
+scalb(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
+scalb(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+scalb(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_scalb<typename P_expr1::T_numtype,int> > >
+scalb(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_scalb<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_scalb<typename P_expr1::T_numtype,float> > >
+scalb(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_scalb<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_scalb<typename P_expr1::T_numtype,double> > >
+scalb(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_scalb<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_scalb<typename P_expr1::T_numtype,long double> > >
+scalb(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_scalb<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > >
+scalb(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<int,typename P_expr2::T_numtype> > >
+scalb(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<float,P_numtype2> > >
+scalb(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<float,typename P_expr2::T_numtype> > >
+scalb(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<double,P_numtype2> > >
+scalb(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<double,typename P_expr2::T_numtype> > >
+scalb(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<long double,P_numtype2> > >
+scalb(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_scalb<long double,typename P_expr2::T_numtype> > >
+scalb(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_scalb<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_scalb<complex<T1> ,P_numtype2> > >
+scalb(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > >
+scalb(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * sin
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_sin<P_numtype1> > >
+sin(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_sin<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_sin<typename P_expr1::T_numtype> > >
+sin(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_sin<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * sinh
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_sinh<P_numtype1> > >
+sinh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_sinh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_sinh<typename P_expr1::T_numtype> > >
+sinh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_sinh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * sqr
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_sqr<P_numtype1> > >
+sqr(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_sqr<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_sqr<typename P_expr1::T_numtype> > >
+sqr(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_sqr<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * sqrt
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_sqrt<P_numtype1> > >
+sqrt(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_sqrt<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_sqrt<typename P_expr1::T_numtype> > >
+sqrt(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_sqrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * tan
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_tan<P_numtype1> > >
+tan(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_tan<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_tan<typename P_expr1::T_numtype> > >
+tan(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_tan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * tanh
+ ****************************************************************************/
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_tanh<P_numtype1> > >
+tanh(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_tanh<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_tanh<typename P_expr1::T_numtype> > >
+tanh(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_tanh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+
+/****************************************************************************
+ * uitrunc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_uitrunc<P_numtype1> > >
+uitrunc(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_uitrunc<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_uitrunc<typename P_expr1::T_numtype> > >
+uitrunc(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_uitrunc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * unordered
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2._bz_getRef()));
+}
+
+template<class P_numtype1, class P_struct1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), d2));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<int>,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+    _bz_unordered<P_numtype1,float> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<float>,
+        _bz_unordered<P_numtype1,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+    _bz_unordered<P_numtype1,double> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<double>,
+        _bz_unordered<P_numtype1,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+    _bz_unordered<P_numtype1,long double> > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<long double>,
+        _bz_unordered<P_numtype1,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class P_struct1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_unordered<P_numtype1,complex<T2> > > >
+unordered(const Matrix<P_numtype1, P_struct1>& d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(), _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
+unordered(_bz_MatExpr<P_expr1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2._bz_getRef()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+unordered(_bz_MatExpr<P_expr1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+    _bz_unordered<typename P_expr1::T_numtype,int> > >
+unordered(_bz_MatExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<int>,
+        _bz_unordered<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+    _bz_unordered<typename P_expr1::T_numtype,float> > >
+unordered(_bz_MatExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<float>,
+        _bz_unordered<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+    _bz_unordered<typename P_expr1::T_numtype,double> > >
+unordered(_bz_MatExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<double>,
+        _bz_unordered<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+    _bz_unordered<typename P_expr1::T_numtype,long double> > >
+unordered(_bz_MatExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<long double>,
+        _bz_unordered<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+    _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > >
+unordered(_bz_MatExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>, _bz_MatExprConstant<complex<T2> > ,
+        _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1, _bz_MatExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(int d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<int,typename P_expr2::T_numtype> > >
+unordered(int d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<int>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<float,P_numtype2> > >
+unordered(float d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<float,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<float,typename P_expr2::T_numtype> > >
+unordered(float d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<float>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<double,P_numtype2> > >
+unordered(double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<double,typename P_expr2::T_numtype> > >
+unordered(double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<double>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<long double,P_numtype2> > >
+unordered(long double d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<long double,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2._bz_getRef()));
+}
+
+template<class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+    _bz_unordered<long double,typename P_expr2::T_numtype> > >
+unordered(long double d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<long double>, _bz_MatExpr<P_expr2>,
+        _bz_unordered<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1), d2));
+}
+
+template<class T1, class P_numtype2, class P_struct2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+    _bz_unordered<complex<T1> ,P_numtype2> > >
+unordered(complex<T1> d1, const Matrix<P_numtype2, P_struct2>& d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatrixRef<P_numtype2, P_struct2>,
+        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2._bz_getRef()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+    _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > >
+unordered(complex<T1> d1, _bz_MatExpr<P_expr2> d2)
+{
+    typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > , _bz_MatExpr<P_expr2>,
+        _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1), d2));
+}
+
+#endif
+
+/****************************************************************************
+ * y0
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_y0<P_numtype1> > >
+y0(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_y0<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_y0<typename P_expr1::T_numtype> > >
+y0(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_y0<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+/****************************************************************************
+ * y1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1, class P_struct1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+    _bz_y1<P_numtype1> > >
+y1(const Matrix<P_numtype1, P_struct1>& d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatrixRef<P_numtype1, P_struct1>,
+        _bz_y1<P_numtype1> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef()));
+}
+
+template<class P_expr1>
+inline
+_bz_MatExpr<_bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+    _bz_y1<typename P_expr1::T_numtype> > >
+y1(_bz_MatExpr<P_expr1> d1)
+{
+    typedef _bz_MatExprUnaryOp<_bz_MatExpr<P_expr1>,
+        _bz_y1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_MatExpr<T_expr>(T_expr(d1));
+}
+
+#endif
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATUOPS_H
Index: /XMLIO_V2/external/include/blitz/matutri.h
===================================================================
--- /XMLIO_V2/external/include/blitz/matutri.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/matutri.h	(revision 73)
@@ -0,0 +1,167 @@
+/***************************************************************************
+ * blitz/matutri.h      Declarations for UpperTriangular matrices
+ *
+ * $Id: matutri.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MATUTRI_H
+#define BZ_MATUTRI_H
+
+#ifndef BZ_MSTRUCT_H
+ #error <blitz/matutri.h> must be included via <blitz/mstruct.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Upper triangular, column major ordering
+// [ 0 1 3 6 ]
+// [ . 2 4 7 ]
+// [ . . 5 8 ]
+// [ . . . 9 ]
+
+class UpperTriangularIterator {
+public:
+    UpperTriangularIterator(unsigned rows, unsigned cols)
+    {
+        BZPRECONDITION(rows == cols);
+        size_ = rows;
+        good_ = true;
+        offset_ = 0;
+        i_ = 0;
+        j_ = 0;
+    }
+   
+    operator bool() const { return good_; }
+
+    void operator++()
+    {
+        BZPRECONDITION(good_);
+        ++offset_;
+        ++i_;
+        if (i_ > j_)
+        {
+            i_ = 0;
+            ++j_;
+            if (j_ == size_)
+                good_ = false;
+        }
+    }
+
+    unsigned row() const
+    { return i_; }
+
+    unsigned col() const
+    { return j_; }
+
+    unsigned offset() const
+    { return offset_; }
+
+protected:
+    unsigned size_;
+    bool     good_;
+    unsigned offset_;
+    unsigned i_, j_;
+};
+
+class UpperTriangular : public MatrixStructure {
+
+public:
+    typedef UpperTriangularIterator T_iterator;
+
+    UpperTriangular()
+        : size_(0)
+    { }
+
+    UpperTriangular(unsigned size)
+        : size_(size)
+    { }
+
+    UpperTriangular(unsigned rows, unsigned cols)
+        : size_(rows)
+    {
+        BZPRECONDITION(rows == cols);
+    }
+
+    unsigned columns() const
+    { return size_; }
+
+    unsigned coordToOffset(unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        BZPRECONDITION(j >= i);
+        return j*(j+1)/2 + i;
+    }
+
+    unsigned firstInRow(unsigned i) const
+    { return 0; }
+
+    template<typename T_numtype>
+    T_numtype get(const T_numtype * restrict data,
+        unsigned i, unsigned j) const
+    {
+        BZPRECONDITION(inRange(i,j));
+        if (j >= i)
+            return data[coordToOffset(i,j)];
+        else
+            return ZeroElement<T_numtype>::zero();
+    }
+
+    template<typename T_numtype>
+    T_numtype& get(T_numtype * restrict data, unsigned i, unsigned j)
+    {
+        BZPRECONDITION(inRange(i,j));
+        if (j >= i)
+            return data[coordToOffset(i,j)];
+        else
+            return ZeroElement<T_numtype>::zero();
+    }
+
+    unsigned lastInRow(unsigned i) const
+    { return size_ - 1; }
+
+    unsigned firstInCol(unsigned j) const
+    { return 0; }
+
+    unsigned lastInCol(unsigned j) const
+    { return j; }
+
+    bool inRange(const unsigned i,const unsigned j) const { return (i<size_) && (j<size_); }
+
+    unsigned numElements() const { return size_ * (size_ + 1) / 2; }
+
+    unsigned rows() const { return size_; }
+
+    void resize(const unsigned size) { size_ = size; }
+
+    void resize(const unsigned rows,const unsigned cols) {
+        BZPRECONDITION(rows == cols);
+        size_  = rows;
+    }
+
+private:
+    unsigned size_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MATUTRI_H
+
Index: /XMLIO_V2/external/include/blitz/memblock.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/memblock.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/memblock.cc	(revision 73)
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_MEMBLOCK_CC
+#define BZ_MEMBLOCK_CC
+
+#include <blitz/numtrait.h>
+
+BZ_NAMESPACE(blitz)
+
+// Null memory block for each (template) instantiation of MemoryBlockReference
+template<typename P_type> 
+NullMemoryBlock<P_type> MemoryBlockReference<P_type>::nullBlock_;
+
+template<typename P_type>
+void MemoryBlock<P_type>::deallocate()
+{
+#ifndef BZ_ALIGN_BLOCKS_ON_CACHELINE_BOUNDARY
+    delete [] dataBlockAddress_;
+#else
+    if (!NumericTypeTraits<T_type>::hasTrivialCtor) {
+        for (int i=0; i < length_; ++i)
+            data_[i].~T_type();
+        delete [] reinterpret_cast<char*>(dataBlockAddress_);
+    }
+    else {
+        delete [] dataBlockAddress_;
+    }
+#endif
+}
+
+template<typename P_type>
+inline void MemoryBlock<P_type>::allocate(size_t length)
+{
+    TAU_TYPE_STRING(p1, "MemoryBlock<T>::allocate() [T="
+        + CT(P_type) + "]");
+    TAU_PROFILE(p1, "void ()", TAU_BLITZ);
+
+#ifndef BZ_ALIGN_BLOCKS_ON_CACHELINE_BOUNDARY
+    dataBlockAddress_ = new T_type[length];
+    data_ = dataBlockAddress_;
+#else
+    size_t numBytes = length * sizeof(T_type);
+
+    if (numBytes < 1024)
+    {
+        dataBlockAddress_ = new T_type[length];
+        data_ = dataBlockAddress_;
+    }
+    else
+    {
+        // We're allocating a large array.  For performance reasons,
+        // it's advantageous to force the array to start on a
+        // cache line boundary.  We do this by allocating a little
+        // more memory than necessary, then shifting the pointer
+        // to the next cache line boundary.
+
+        // Patches by Petter Urkedal to support types with nontrivial
+        // constructors.
+
+        const int cacheBlockSize = 128;    // Will work for 32, 16 also
+
+        dataBlockAddress_ = reinterpret_cast<T_type*>
+            (new char[numBytes + cacheBlockSize - 1]);
+
+        // Shift to the next cache line boundary
+
+        ptrdiff_t offset = ptrdiff_t(dataBlockAddress_) % cacheBlockSize;
+        ptrdiff_t shift = (offset == 0) ? 0 : (cacheBlockSize - offset);
+        data_ = reinterpret_cast<T_type*>
+                (reinterpret_cast<char*>(dataBlockAddress_) + shift);
+
+        // Use placement new to construct types with nontrival ctors
+        if (!NumericTypeTraits<T_type>::hasTrivialCtor) {
+            for (int i=0; i < length; ++i)
+                new(&data_[i]) T_type;
+        }
+    }
+#endif
+}
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_MEMBLOCK_CC
Index: /XMLIO_V2/external/include/blitz/memblock.h
===================================================================
--- /XMLIO_V2/external/include/blitz/memblock.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/memblock.h	(revision 73)
@@ -0,0 +1,360 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/memblock.h      MemoryBlock<T> and MemoryBlockReference<T>
+ *
+ * $Id: memblock.h,v 1.18 2005/10/11 21:54:57 julianc Exp $
+ *
+ * Copyright (C) 1997-1999 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MEMBLOCK_H
+#define BZ_MEMBLOCK_H
+
+#include <blitz/blitz.h>
+
+#include <stddef.h>     // ptrdiff_t
+
+#ifdef BZ_THREADSAFE
+ #include <pthread.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+enum preexistingMemoryPolicy { 
+  duplicateData, 
+  deleteDataWhenDone, 
+  neverDeleteData 
+};
+
+// Forward declaration of MemoryBlockReference
+template<typename T_type> class MemoryBlockReference;
+
+// Class MemoryBlock provides a reference-counted block of memory.  This block
+// may be referred to by multiple vector, matrix and array objects.  The memory
+// is automatically deallocated when the last referring object is destructed.
+// MemoryBlock may be subclassed to provide special allocators.
+template<typename P_type>
+class MemoryBlock {
+
+    friend class MemoryBlockReference<P_type>;
+
+public:
+    typedef P_type T_type;
+
+protected:
+    MemoryBlock()
+    {
+        length_ = 0;
+        data_ = 0;
+        dataBlockAddress_ = 0;
+        references_ = 0;
+
+        BZ_MUTEX_INIT(mutex)
+    }
+
+    explicit MemoryBlock(size_t items)
+    {
+        length_ = items;
+        allocate(length_);
+
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlock: allocated " << setw(8) << length_ 
+         << " at " << ((void *)dataBlockAddress_) << endl;
+#endif
+
+        BZASSERT(dataBlockAddress_ != 0);
+
+        references_ = 0;
+
+        BZ_MUTEX_INIT(mutex)
+    }
+
+    MemoryBlock(size_t length, T_type* data)
+    {
+        length_ = length;
+        data_ = data;
+        dataBlockAddress_ = data;
+        references_ = 0;
+        BZ_MUTEX_INIT(mutex)
+    }
+
+    virtual ~MemoryBlock()
+    {
+        if (dataBlockAddress_) 
+        {
+
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlock:     freed " << setw(8) << length_
+         << " at " << ((void *)dataBlockAddress_) << endl;
+#endif
+
+            deallocate();
+        }
+
+        BZ_MUTEX_DESTROY(mutex)
+    }
+
+    void          addReference()
+    { 
+        BZ_MUTEX_LOCK(mutex)
+        ++references_; 
+
+#ifdef BZ_DEBUG_LOG_REFERENCES
+    cout << "MemoryBlock:    reffed " << setw(8) << length_ 
+         << " at " << ((void *)dataBlockAddress_) << " (r=" 
+         << (int)references_ << ")" << endl;
+#endif
+        BZ_MUTEX_UNLOCK(mutex)
+
+    }
+
+    T_type* restrict      data() 
+    { 
+        return data_; 
+    }
+
+    const T_type* restrict data()      const
+    { 
+        return data_; 
+    }
+
+    T_type*&      dataBlockAddress() 
+    { 
+        return dataBlockAddress_; 
+    }
+
+    size_t        length()    const
+    { 
+        return length_; 
+    }
+
+    int           removeReference()
+    {
+
+        BZ_MUTEX_LOCK(mutex)
+        int refcount = --references_;
+
+#ifdef BZ_DEBUG_LOG_REFERENCES
+    cout << "MemoryBlock: dereffed  " << setw(8) << length_
+         << " at " << ((void *)dataBlockAddress_) << " (r=" << (int)references_ 
+         << ")" << endl;
+#endif
+        BZ_MUTEX_UNLOCK(mutex)
+        return refcount;
+    }
+
+    int references() const
+    {
+        BZ_MUTEX_LOCK(mutex)
+        int refcount = references_;
+        BZ_MUTEX_UNLOCK(mutex)
+
+        return refcount;
+    }
+
+protected:
+    inline void allocate(size_t length);
+    void deallocate();
+
+private:   // Disabled member functions
+    MemoryBlock(const MemoryBlock<T_type>&)
+    { }
+
+    void operator=(const MemoryBlock<T_type>&)
+    { }
+
+private:   // Data members
+    T_type * restrict     data_;
+    T_type *              dataBlockAddress_;
+
+#ifdef BZ_DEBUG_REFERENCE_ROLLOVER
+    volatile unsigned char references_;
+#else
+    volatile int references_;
+#endif
+
+    BZ_MUTEX_DECLARE(mutex)
+    size_t  length_;
+};
+
+template<typename P_type>
+class UnownedMemoryBlock : public MemoryBlock<P_type> {
+public:
+    UnownedMemoryBlock(size_t length, P_type* data)
+        : MemoryBlock<P_type>(length,data)
+    {
+        // This ensures that MemoryBlock destructor will not 
+        // attempt to delete data
+        MemoryBlock<P_type>::dataBlockAddress() = 0;
+    }
+
+    virtual ~UnownedMemoryBlock()
+    {
+    }
+};
+
+template<typename P_type>
+class NullMemoryBlock : public MemoryBlock<P_type> {
+public:
+    NullMemoryBlock()
+    { 
+        // This ensures that the delete operator will not be invoked
+        // on an instance of NullMemoryBlock in removeReference().
+        MemoryBlock<P_type>::addReference();        
+    }
+
+    virtual ~NullMemoryBlock()  
+    { }
+};
+
+template<typename P_type>
+class MemoryBlockReference {
+
+public:
+    typedef P_type T_type;
+
+protected:
+    T_type * restrict data_;
+
+private:
+    MemoryBlock<T_type>* block_;
+    static NullMemoryBlock<T_type> nullBlock_;
+
+public:
+
+    MemoryBlockReference()
+    {
+        block_ = &nullBlock_;
+        block_->addReference();
+        data_ = 0;
+    }
+
+    MemoryBlockReference(MemoryBlockReference<T_type>& ref, size_t offset=0)
+    {
+        block_ = ref.block_;
+        block_->addReference();
+        data_ = ref.data_ + offset;
+    }
+
+    MemoryBlockReference(size_t length, T_type* data, 
+        preexistingMemoryPolicy deletionPolicy)
+    {
+        // Create a memory block using already allocated memory. 
+
+        // Note: if the deletionPolicy is duplicateData, this must
+        // be handled by the leaf class.  In MemoryBlockReference,
+        // this is treated as neverDeleteData; the leaf class (e.g. Array)
+        // must duplicate the data.
+
+        if ((deletionPolicy == neverDeleteData) 
+          || (deletionPolicy == duplicateData))
+            block_ = new UnownedMemoryBlock<T_type>(length, data);
+        else if (deletionPolicy == deleteDataWhenDone)
+            block_ = new MemoryBlock<T_type>(length, data);
+        block_->addReference();
+
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlockReference: created MemoryBlock at "
+         << ((void*)block_) << endl;
+#endif
+
+        data_ = data;
+    }
+
+    explicit MemoryBlockReference(size_t items)
+    {
+        block_ = new MemoryBlock<T_type>(items);
+        block_->addReference();
+        data_ = block_->data();
+
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlockReference: created MemoryBlock at "
+         << ((void*)block_) << endl;
+#endif
+
+    }
+
+    void blockRemoveReference()
+    {
+        int refcount = block_->removeReference();
+        if ((refcount == 0) && (block_ != &nullBlock_))
+        {
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlock: no more refs, delete MemoryBlock object at "
+         << ((void*)block_) << endl;
+#endif
+
+            delete block_;
+        }
+    }
+
+   ~MemoryBlockReference()
+    {
+        blockRemoveReference();
+    }
+
+    int numReferences() const
+    {
+        return block_->references();
+    }
+
+
+protected:
+
+    void changeToNullBlock()
+    {
+        blockRemoveReference();
+        block_ = &nullBlock_;
+        block_->addReference();
+        data_ = 0;
+    }
+
+    void changeBlock(MemoryBlockReference<T_type>& ref, size_t offset=0)
+    {
+        blockRemoveReference();
+        block_ = ref.block_;
+        block_->addReference();
+        data_ = ref.data_ + offset;
+    }
+
+    void newBlock(size_t items)
+    {
+        blockRemoveReference();
+        block_ = new MemoryBlock<T_type>(items);
+        block_->addReference();
+        data_ = block_->data();
+
+#ifdef BZ_DEBUG_LOG_ALLOCATIONS
+    cout << "MemoryBlockReference: created MemoryBlock at "
+         << ((void*)block_) << endl;
+#endif
+    }
+
+private:
+    void operator=(const MemoryBlockReference<T_type>&)
+    { }
+};
+
+
+BZ_NAMESPACE_END
+
+#include <blitz/memblock.cc>
+
+#endif // BZ_MEMBLOCK_H
Index: /XMLIO_V2/external/include/blitz/minmax.h
===================================================================
--- /XMLIO_V2/external/include/blitz/minmax.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/minmax.h	(revision 73)
@@ -0,0 +1,66 @@
+/***************************************************************************
+ * blitz/minmax.h  Declaration of min and max functions
+ *
+ * $Id: minmax.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MINMAX_H
+#define BZ_MINMAX_H
+
+#include <blitz/promote.h>
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * These functions are in their own namespace (blitz::minmax) to avoid
+ * conflicts with the array reduction operations min and max.
+ */
+
+BZ_NAMESPACE(minmax)
+
+template<typename T1, typename T2>
+BZ_PROMOTE(T1,T2) min(const T1& a, const T2& b)
+{
+    typedef BZ_PROMOTE(T1,T2) T_promote;
+
+    if (a <= b)
+        return T_promote(a);
+    else
+        return T_promote(b);
+}
+
+template<typename T1, typename T2>
+BZ_PROMOTE(T1,T2) max(const T1& a, const T2& b)
+{
+    typedef BZ_PROMOTE(T1,T2) T_promote;
+
+    if (a >= b)
+        return T_promote(a);
+    else
+        return T_promote(b);
+}
+
+BZ_NAMESPACE_END
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/mstruct.h
===================================================================
--- /XMLIO_V2/external/include/blitz/mstruct.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/mstruct.h	(revision 73)
@@ -0,0 +1,129 @@
+/***************************************************************************
+ * blitz/mstruct.h      Matrix structure classes
+ *
+ * $Id: mstruct.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_MSTRUCT_H
+#define BZ_MSTRUCT_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_ZERO_H
+ #include <blitz/zero.h>
+#endif
+
+/*
+ * Each matrix structure class encapsulates a storage format for matrix
+ * data.  It is responsible for:
+ * - Storing the size of the matrix
+ * - Calculating how many unique elements the matrix will have
+ * - Mapping indices (i,j) onto memory locations
+ * - Performing any sign reversals or conjugations when matrix
+ *   elements are retrieved (e.g. in a Hermitian or Skew symmetric
+ *   matrix)
+ *
+ * Every matrix structure class must provide these methods:
+ *
+ * ctor()
+ * ctor(unsigned rows, unsigned cols)
+ * unsigned columns() const;
+ * unsigned cols()    const;
+ * unsigned firstInRow() const;
+ * unsigned firstInCol() const;
+ * template<typename T> T& get(T* data, unsigned i, unsigned j);
+ * template<typename T> T  get(const T* data, unsigned i, unsigned j) const;
+ * bool inRange(unsigned i, unsigned j) const
+ * unsigned lastInRow() const;
+ * unsigned lastInCol() const;
+ * unsigned numElements() const;
+ * void resize(unsigned rows, unsigned cols);
+ * unsigned rows()    const;
+ *
+ * Each matrix structure class must declare a public type
+ * T_iterator which is an iterator to scan through the unique
+ * entries of the matrix.  The iterator class must provide
+ * these methods:
+ *
+ * ctor(unsigned rows, unsigned cols)
+ * unsigned offset() const
+ * operator bool() const
+ * unsigned row() const
+ * unsigned col() const
+ */
+
+BZ_NAMESPACE(blitz)
+
+class MatrixStructure { };
+
+class AsymmetricMatrix : public MatrixStructure {
+public:
+    AsymmetricMatrix()
+        : rows_(0), cols_(0)
+    { }
+
+    AsymmetricMatrix(unsigned rows, unsigned cols)
+        : rows_(rows), cols_(cols)
+    { }
+
+    unsigned columns() const { return cols_; }
+
+    unsigned cols() const { return cols_; }
+
+    bool inRange(const unsigned i,const unsigned j) const {
+        return (i<rows_) && (j<cols_);
+    }
+
+    void resize(unsigned rows, unsigned cols) {
+        rows_ = rows;
+        cols_ = cols;
+    }
+
+    unsigned rows() const { return rows_; }
+
+protected:
+    unsigned rows_, cols_;
+};
+
+// Still to be implemented:
+// SkewSymmetric
+// Hermitian
+// Tridiagonal
+// Banded<L,H>
+// Upper bidiagonal
+// Lower bidiagonal
+// Upper Hessenberg
+// Lower Hessenberg
+
+BZ_NAMESPACE_END
+
+#include <blitz/matgen.h>         // RowMajor and ColumnMajor general matrices
+#include <blitz/matsymm.h>        // Symmetric
+#include <blitz/matdiag.h>        // Diagonal
+#include <blitz/mattoep.h>        // Toeplitz
+#include <blitz/matltri.h>        // Lower triangular
+#include <blitz/matutri.h>        // Upper triangular
+
+#endif // BZ_MSTRUCT_H
Index: /XMLIO_V2/external/include/blitz/numinquire.h
===================================================================
--- /XMLIO_V2/external/include/blitz/numinquire.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/numinquire.h	(revision 73)
@@ -0,0 +1,306 @@
+/***************************************************************************
+ * blitz/numinquire.h    Numeric inquiry functions
+ *
+ * $Id: numinquire.h,v 1.5 2005/02/23 12:39:27 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+/*
+ * These numeric inquiry functions are provided as an alternative
+ * to the somewhat klunky numeric_limits<T>::yadda_yadda syntax.
+ * Where a similar Fortran 90 function exists, the same name has
+ * been used.
+ *
+ * The argument in all cases is a dummy of the appropriate type
+ * (double, int, etc.)
+ *
+ * These functions assume that numeric_limits<T> has been specialized
+ * for the appropriate case.  If not, the results are not useful.
+ */
+
+#ifndef BZ_NUMINQUIRE_H
+#define BZ_NUMINQUIRE_H
+
+#ifndef BZ_BLITZ_H
+  #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_HAVE_NUMERIC_LIMITS
+  #include <blitz/limits-hack.h>
+#else
+  #include <limits>
+#endif
+
+#ifndef BZ_RANGE_H
+ #include <blitz/range.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * This traits class provides zero and one values for numeric
+ * types.  This was previously a template function with specializations,
+ * but the specializations were causing multiply-defined symbols
+ * at link time.  TV 980226
+ */
+
+template<typename T_numtype>
+struct _bz_OneZeroTraits {
+    static inline T_numtype zero() { return 0; }
+    static inline T_numtype one()  { return 1; }
+};
+
+#ifdef BZ_HAVE_COMPLEX
+
+template<>
+struct _bz_OneZeroTraits<complex<float> > {
+    static inline complex<float> zero() { return complex<float>(0.0f,0.0f); }
+    static inline complex<float> one()  { return complex<float>(1.0f,0.0f); }
+};
+
+template<>
+struct _bz_OneZeroTraits<complex<double> > {
+    static inline complex<double> zero() { return complex<double>(0.0,0.0); }
+    static inline complex<double> one()  { return complex<double>(1.0,0.0); }
+};
+
+template<>
+struct _bz_OneZeroTraits<complex<long double> > {
+    static inline complex<long double> zero() 
+    { return complex<long double>(0.0,0.0); }
+
+    static inline complex<long double> one()  
+    { return complex<long double>(1.0,0.0); }
+};
+
+#endif // BZ_HAVE_COMPLEX
+
+template<typename T>
+inline T zero(T)
+{
+    return _bz_OneZeroTraits<T>::zero();
+}
+
+template<typename T>
+inline T one(T)
+{
+    return _bz_OneZeroTraits<T>::one();
+}
+
+template<typename T>
+inline int digits(T)
+{
+    return numeric_limits<T>::digits;
+}
+
+template<typename T>
+inline int digits10(T)
+{
+    return numeric_limits<T>::digits10;
+}
+
+template<typename T>
+inline T epsilon(T) BZ_THROW
+{
+    return numeric_limits<T>::epsilon();
+}
+
+// neghuge() by Theodore Papadopoulo, to fix a problem with
+// max() reductions.
+template<typename T>
+inline T neghuge(T) BZ_THROW
+{
+    return numeric_limits<T>::is_integer ?    numeric_limits<T>::min()
+                                         : - numeric_limits<T>::max();
+}
+
+template<typename T>
+inline T huge(T) BZ_THROW
+{
+    return numeric_limits<T>::max();
+}
+
+template<typename T>
+inline T tiny(T) BZ_THROW
+{
+    return numeric_limits<T>::min();
+}
+
+template<typename T>
+inline int max_exponent(T)
+{
+    return numeric_limits<T>::max_exponent;
+}
+
+template<typename T>
+inline int min_exponent(T)
+{
+    return numeric_limits<T>::min_exponent;
+}
+
+template<typename T>
+inline int min_exponent10(T)
+{
+    return numeric_limits<T>::min_exponent10;
+}
+
+template<typename T>
+inline int max_exponent10(T)
+{
+    return numeric_limits<T>::max_exponent10;
+}
+
+template<typename T>
+inline int precision(T)
+{
+    return numeric_limits<T>::digits10;
+}
+
+template<typename T>
+inline int radix(T)
+{
+    return numeric_limits<T>::radix;
+}
+
+template<typename T>
+inline Range range(T)
+{
+    return Range(numeric_limits<T>::min_exponent10, 
+        numeric_limits<T>::max_exponent10);
+}
+
+template<typename T>
+inline bool is_signed(T) {
+    return numeric_limits<T>::is_signed;
+}
+
+template<typename T>
+inline bool is_integer(T) {
+    return numeric_limits<T>::is_integer;
+}
+
+template<typename T>
+inline bool is_exact(T) {
+    return numeric_limits<T>::is_exact;
+}
+
+template<typename T>
+inline T round_error(T) BZ_THROW
+{
+    return numeric_limits<T>::round_error();
+}
+
+template<typename T>
+inline bool has_infinity(T) {
+    return numeric_limits<T>::has_infinity;
+}
+
+template<typename T>
+inline bool has_quiet_NaN(T) {
+    return numeric_limits<T>::has_quiet_NaN;
+}
+
+template<typename T>
+inline bool has_signaling_NaN(T) {
+    return numeric_limits<T>::has_signaling_NaN;
+}
+
+// Provided for non-US english users
+template<typename T>
+inline bool has_signalling_NaN(T) {
+    return numeric_limits<T>::has_signaling_NaN;
+}
+
+template<typename T>
+inline bool has_denorm(T) {
+    return numeric_limits<T>::has_denorm;
+}
+
+template<typename T>
+inline bool has_denorm_loss(T) {
+    return numeric_limits<T>::has_denorm_loss;
+}
+
+template<typename T>
+inline T infinity(T) BZ_THROW
+{
+    return numeric_limits<T>::infinity();
+}
+
+template<typename T>
+inline T quiet_NaN(T) BZ_THROW
+{
+    return numeric_limits<T>::quiet_NaN();
+}
+
+template<typename T>
+inline T signaling_NaN(T) BZ_THROW
+{
+    return numeric_limits<T>::signaling_NaN();
+}
+
+template<typename T>
+inline T signalling_NaN(T) BZ_THROW
+{
+    return numeric_limits<T>::signaling_NaN();
+}
+
+template<typename T>
+inline T denorm_min(T) BZ_THROW
+{
+    return numeric_limits<T>::denorm_min();
+}
+
+template<typename T>
+inline bool is_iec559(T) {
+    return numeric_limits<T>::is_iec559;
+}
+
+template<typename T>
+inline bool is_bounded(T) {
+    return numeric_limits<T>::is_bounded;
+}
+
+template<typename T>
+inline bool is_modulo(T) {
+    return numeric_limits<T>::is_modulo;
+}
+
+template<typename T>
+inline bool traps(T) {
+    return numeric_limits<T>::traps;
+}
+
+template<typename T>
+inline bool tinyness_before(T) {
+    return numeric_limits<T>::tinyness_before;
+}
+
+template<typename T>
+inline BZ_STD_SCOPE(float_round_style) round_style(T)
+{
+    return numeric_limits<T>::round_style;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_NUMINQUIRE_H
+
Index: /XMLIO_V2/external/include/blitz/numtrait.h
===================================================================
--- /XMLIO_V2/external/include/blitz/numtrait.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/numtrait.h	(revision 73)
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/numtrait.h      Declaration of the NumericTypeTraits class
+ *
+ * $Id: numtrait.h,v 1.6 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_NUMTRAIT_H
+#define BZ_NUMTRAIT_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+#ifndef BZ_USE_NUMTRAIT
+  #define BZ_SUMTYPE(X)    X
+  #define BZ_DIFFTYPE(X)   X
+  #define BZ_FLOATTYPE(X)  X
+  #define BZ_SIGNEDTYPE(X) X
+#else
+
+#define BZ_SUMTYPE(X)   _bz_typename NumericTypeTraits<X>::T_sumtype
+#define BZ_DIFFTYPE(X)  _bz_typename NumericTypeTraits<X>::T_difftype
+#define BZ_FLOATTYPE(X) _bz_typename NumericTypeTraits<X>::T_floattype
+#define BZ_SIGNEDTYPE(X) _bz_typename NumericTypeTraits<X>::T_signedtype
+
+template<typename P_numtype>
+class NumericTypeTraits {
+public:
+    typedef P_numtype T_sumtype;    // Type to be used for summing
+    typedef P_numtype T_difftype;   // Type to be used for difference
+    typedef P_numtype T_floattype;  // Type to be used for floating-point
+                                    // calculations
+    typedef P_numtype T_signedtype; // Type to be used for signed calculations
+    enum { hasTrivialCtor = 0 };    // Assume the worst
+};
+
+#define BZDECLNUMTRAIT(X,Y,Z,W,U)                                   \
+    template<>                                                      \
+    class NumericTypeTraits<X> {                                    \
+    public:                                                         \
+        typedef Y T_sumtype;                                        \
+        typedef Z T_difftype;                                       \
+        typedef W T_floattype;                                      \
+        typedef U T_signedtype;                                     \
+        enum { hasTrivialCtor = 1 };                                \
+    }                                                               
+
+#ifdef BZ_HAVE_BOOL
+    BZDECLNUMTRAIT(bool,unsigned,int,float,int);
+#endif
+
+BZDECLNUMTRAIT(char,int,int,float,char);
+BZDECLNUMTRAIT(unsigned char, unsigned, int, float,int);
+BZDECLNUMTRAIT(short int, int, int, float, short int);
+BZDECLNUMTRAIT(short unsigned int, unsigned int, int, float, int);
+BZDECLNUMTRAIT(int, long, int, float, int);
+BZDECLNUMTRAIT(unsigned int, unsigned long, int, float, long);
+BZDECLNUMTRAIT(long, long, long, double, long);
+BZDECLNUMTRAIT(unsigned long, unsigned long, long, double, long);
+BZDECLNUMTRAIT(float, double, float, float, float);
+BZDECLNUMTRAIT(double, double, double, double, double);
+
+#ifdef BZ_HAVE_COMPLEX
+// BZDECLNUMTRAIT(complex<float>, complex<double>, complex<float>, complex<float>);
+// BZDECLNUMTRAIT(complex<double>, complex<long double>, complex<double>, complex<double>);
+#endif // BZ_HAVE_COMPLEX
+
+#endif // BZ_USE_NUMTRAIT
+
+BZ_NAMESPACE_END
+
+#endif // BZ_NUMTRAIT_H
Index: /XMLIO_V2/external/include/blitz/ops.h
===================================================================
--- /XMLIO_V2/external/include/blitz/ops.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/ops.h	(revision 73)
@@ -0,0 +1,188 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/ops.h           Function objects for math operators
+ *
+ * $Id: ops.h,v 1.7 2004/03/09 21:56:00 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ *************************************************************************/
+
+#ifndef BZ_OPS_H
+#define BZ_OPS_H
+
+#include <blitz/blitz.h>
+#include <blitz/promote.h>
+#include <blitz/prettyprint.h>
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * Originally these function objects had no template arguments, e.g.
+ *
+ * struct Add {
+ *     template<typename T_numtype1, typename T_numtype2>
+ *     static inline BZ_PROMOTE(T_numtype1, T_numtype2)
+ *     apply(T_numtype1 a, T_numtype2 b)
+ *     { return a + b; }
+ * };
+ *
+ * This made for neater expression templates syntax.  However, there are
+ * some situations in which users may want to override type promotion
+ * for certain operations.  For example, in theoretical physics, there
+ * are U1 objects which when multiplied yield U1 objects, but when added
+ * yield a different type.  To allow for this kind of behaviour, function
+ * objects have been changed to take template parameters:
+ *
+ * template<typename T_numtype1, typename T_numtype2>
+ * struct Add {
+ *     typedef BZ_PROMOTE(T_numtype1, T_numtype2) T_numtype;
+ *
+ *     static inline T_numtype apply(T_numtype1 a, T_numtype2 b)
+ *     { return a + b; }
+ * };
+ *
+ * Type promotion is performed inside the function object.  The expression
+ * templates code always looks inside the function object to determine
+ * the type promotion, e.g. Add<int,float>::T_numtype
+ *
+ * Users are free to specialize these function objects for their own types.
+ */
+    
+/* Unary operators that return same type as argument */
+    
+#define BZ_DEFINE_UNARY_OP(name,op)                            \
+template<typename T_numtype1>                                  \
+struct name {                                                  \
+    typedef T_numtype1 T_numtype;                              \
+                                                               \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return op a; }                                           \
+							       \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #op;                                            \
+        t1.prettyPrint(str, format);                           \
+    }                                                          \
+};
+
+BZ_DEFINE_UNARY_OP(BitwiseNot,~)
+BZ_DEFINE_UNARY_OP(UnaryPlus,+)
+BZ_DEFINE_UNARY_OP(UnaryMinus,-)
+    
+    
+/* Unary operators that return a specified type */
+    
+#define BZ_DEFINE_UNARY_OP_RET(name,op,ret)                    \
+template<typename T_numtype1>                                  \
+struct name {                                                  \
+    typedef ret T_numtype;                                     \
+    static inline T_numtype                                    \
+    apply(T_numtype1 a)                                        \
+    { return op a; }                                           \
+                                                               \
+    template<typename T1>                                      \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,  \
+        prettyPrintFormat& format, const T1& t1)               \
+    {                                                          \
+        str += #op;                                            \
+        t1.prettyPrint(str, format);                           \
+    }                                                          \
+};
+
+BZ_DEFINE_UNARY_OP_RET(LogicalNot,!,bool)
+    
+    
+/* Binary operators that return type based on type promotion */
+    
+#define BZ_DEFINE_BINARY_OP(name,op)                              \
+template<typename T_numtype1, typename T_numtype2>                \
+struct name {                                                     \
+    typedef BZ_PROMOTE(T_numtype1, T_numtype2) T_numtype;         \
+                                                                  \
+    static inline T_numtype                                       \
+    apply(T_numtype1 a, T_numtype2 b)                             \
+    { return a op b; }                                            \
+							          \
+    template<typename T1, typename T2>                            \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,     \
+        prettyPrintFormat& format, const T1& t1,                  \
+        const T2& t2)                                             \
+    {                                                             \
+        str += "(";                                               \
+        t1.prettyPrint(str, format);                              \
+        str += #op;                                               \
+        t2.prettyPrint(str, format);                              \
+        str += ")";                                               \
+    }                                                             \
+};
+
+BZ_DEFINE_BINARY_OP(Add,+)
+BZ_DEFINE_BINARY_OP(Subtract,-)
+BZ_DEFINE_BINARY_OP(Multiply,*)
+BZ_DEFINE_BINARY_OP(Divide,/)
+BZ_DEFINE_BINARY_OP(Modulo,%)
+BZ_DEFINE_BINARY_OP(BitwiseXor,^)
+BZ_DEFINE_BINARY_OP(BitwiseAnd,&)
+BZ_DEFINE_BINARY_OP(BitwiseOr,|)
+BZ_DEFINE_BINARY_OP(ShiftRight,>>)
+BZ_DEFINE_BINARY_OP(ShiftLeft,<<)
+    
+    
+/* Binary operators that return a specified type */
+    
+#define BZ_DEFINE_BINARY_OP_RET(name,op,ret)                      \
+template<typename T_numtype1, typename T_numtype2>                \
+struct name {                                                     \
+    typedef ret T_numtype;                                        \
+    static inline T_numtype                                       \
+    apply(T_numtype1 a, T_numtype2 b)                             \
+    { return a op b; }                                            \
+                                                                  \
+    template<typename T1, typename T2>                            \
+    static inline void prettyPrint(BZ_STD_SCOPE(string) &str,     \
+        prettyPrintFormat& format, const T1& t1,                  \
+        const T2& t2)                                             \
+    {                                                             \
+        str += "(";                                               \
+        t1.prettyPrint(str, format);                              \
+        str += #op;                                               \
+        t2.prettyPrint(str, format);                              \
+        str += ")";                                               \
+    }                                                             \
+};
+
+BZ_DEFINE_BINARY_OP_RET(Greater,>,bool)
+BZ_DEFINE_BINARY_OP_RET(Less,<,bool)
+BZ_DEFINE_BINARY_OP_RET(GreaterOrEqual,>=,bool)
+BZ_DEFINE_BINARY_OP_RET(LessOrEqual,<=,bool)
+BZ_DEFINE_BINARY_OP_RET(Equal,==,bool)
+BZ_DEFINE_BINARY_OP_RET(NotEqual,!=,bool)
+BZ_DEFINE_BINARY_OP_RET(LogicalAnd,&&,bool)
+BZ_DEFINE_BINARY_OP_RET(LogicalOr,||,bool)
+    
+    
+BZ_NAMESPACE_END
+
+#endif // BZ_OPS_H
+
+
Index: /XMLIO_V2/external/include/blitz/prettyprint.h
===================================================================
--- /XMLIO_V2/external/include/blitz/prettyprint.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/prettyprint.h	(revision 73)
@@ -0,0 +1,66 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/prettyprint.h      Format object for pretty-printing of
+ *                          array expressions
+ *
+ * $Id: prettyprint.h,v 1.5 2004/03/09 23:23:43 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_PRETTYPRINT_H
+#define BZ_PRETTYPRINT_H
+
+BZ_NAMESPACE(blitz)
+
+class prettyPrintFormat {
+
+public:
+    prettyPrintFormat(const bool terse = false)
+        : tersePrintingSelected_(terse) 
+    {
+        arrayOperandCounter_ = 0;
+        scalarOperandCounter_ = 0;
+        dumpArrayShapes_ = false;
+    }
+
+    void setDumpArrayShapesMode()  { dumpArrayShapes_ = true; }
+    char nextArrayOperandSymbol()  
+    { 
+        return static_cast<char>('A' + ((arrayOperandCounter_++) % 26)); 
+    }
+    char nextScalarOperandSymbol() 
+    { 
+        return static_cast<char>('s' + ((scalarOperandCounter_++) % 26)); 
+    }
+
+    bool tersePrintingSelected() const { return tersePrintingSelected_; }
+    bool dumpArrayShapesMode()   const { return dumpArrayShapes_; }
+
+private:
+    bool tersePrintingSelected_;
+    bool dumpArrayShapes_;
+    int arrayOperandCounter_;
+    int scalarOperandCounter_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_PRETTYPRINT_H
Index: /XMLIO_V2/external/include/blitz/promote-old.h
===================================================================
--- /XMLIO_V2/external/include/blitz/promote-old.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/promote-old.h	(revision 73)
@@ -0,0 +1,1359 @@
+/***********************************************************************
+ * promote.h   Arithmetic type promotion trait class
+ * Author: Todd Veldhuizen         (tveldhui@oonumerics.org)
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************
+ */
+
+// Generated: genpromote.cpp Dec 10 2003 17:58:28
+template<typename A, typename B>
+class promote_trait {
+public:
+        typedef A   T_promote;
+};
+
+
+template<>
+class promote_trait<char, char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<char, unsigned char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<char, short int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<char, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<char, int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<char, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<char, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<char, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<char, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<char, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<char, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<char, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<char, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<char, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<unsigned char, char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, unsigned char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, short int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<unsigned char, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned char, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned char, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned char, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<short int, char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<short int, unsigned char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<short int, short int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<short int, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short int, int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<short int, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short int, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<short int, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<short int, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<short int, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<short int, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short int, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short int, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short int, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<short unsigned int, char> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, unsigned char> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, short int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<short unsigned int, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short unsigned int, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short unsigned int, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<short unsigned int, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<int, char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<int, unsigned char> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<int, short int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<int, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<int, int> {
+public:
+	typedef int T_promote;
+};
+
+template<>
+class promote_trait<int, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<int, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<int, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<int, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<int, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<int, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<int, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<int, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<int, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<unsigned int, char> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, unsigned char> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, short int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, short unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, unsigned int> {
+public:
+	typedef unsigned int T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<unsigned int, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned int, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned int, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned int, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<long, char> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, unsigned char> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, short int> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, short unsigned int> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, int> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, unsigned int> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, long> {
+public:
+	typedef long T_promote;
+};
+
+template<>
+class promote_trait<long, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<long, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<long, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<long, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<unsigned long, char> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, unsigned char> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, short int> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, short unsigned int> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, int> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, unsigned int> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, unsigned long> {
+public:
+	typedef unsigned long T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<unsigned long, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned long, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned long, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<unsigned long, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<float, char> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, unsigned char> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, short int> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, short unsigned int> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, int> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, unsigned int> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, long> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, unsigned long> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, float> {
+public:
+	typedef float T_promote;
+};
+
+template<>
+class promote_trait<float, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<float, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<float, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<float, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<float, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<double, char> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, unsigned char> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, short int> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, short unsigned int> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, int> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, unsigned int> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, long> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, unsigned long> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, float> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, double> {
+public:
+	typedef double T_promote;
+};
+
+template<>
+class promote_trait<double, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<double, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<double, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<double, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+template<>
+class promote_trait<long double, char> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, unsigned char> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, short int> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, short unsigned int> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, int> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, unsigned int> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, long> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, unsigned long> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, float> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, double> {
+public:
+	typedef long double T_promote;
+};
+
+template<>
+class promote_trait<long double, long double> {
+public:
+	typedef long double T_promote;
+};
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long double, complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long double, complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<long double, complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , char> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , unsigned char> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , short int> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , short unsigned int> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , int> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , unsigned int> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , long> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , unsigned long> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , float> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , double> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , long double> {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , complex<float> > {
+public:
+	typedef complex<float>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<float> , complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , char> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , unsigned char> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , short int> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , short unsigned int> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , int> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , unsigned int> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , long> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , unsigned long> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , float> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , double> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , long double> {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , complex<float> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , complex<double> > {
+public:
+	typedef complex<double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<double> , complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , char> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , unsigned char> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , short int> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , short unsigned int> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , int> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , unsigned int> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , long> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , unsigned long> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , float> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , double> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , long double> {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , complex<float> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , complex<double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
+#ifdef BZ_HAVE_COMPLEX
+template<>
+class promote_trait<complex<long double> , complex<long double> > {
+public:
+	typedef complex<long double>  T_promote;
+};
+#endif
+
Index: /XMLIO_V2/external/include/blitz/promote.h
===================================================================
--- /XMLIO_V2/external/include/blitz/promote.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/promote.h	(revision 73)
@@ -0,0 +1,166 @@
+// -*- C++ -*-
+/***********************************************************************
+ * promote.h   Arithmetic type promotion trait class
+ * Author: Todd Veldhuizen         (tveldhui@oonumerics.org)
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_PROMOTE_H
+#define BZ_PROMOTE_H
+
+#include <blitz/blitz.h>
+
+BZ_NAMESPACE(blitz)
+
+#ifdef BZ_HAVE_TEMPLATE_QUALIFIED_RETURN_TYPE
+    #define BZ_PROMOTE(A,B) _bz_typename BZ_BLITZ_SCOPE(promote_trait)<A,B>::T_promote
+#else
+    #define BZ_PROMOTE(A,B) A
+#endif
+
+#if defined(BZ_HAVE_PARTIAL_SPECIALIZATION) && !defined(BZ_DISABLE_NEW_PROMOTE)
+
+/*
+ * This compiler supports partial specialization, so type promotion
+ * can be done the elegant way.  This implementation is after ideas
+ * by Jean-Louis Leroy.
+ */
+
+template<typename T>
+struct precision_trait {
+    static const int precisionRank = 0;
+    static const bool knowPrecisionRank = false;
+};
+
+#define BZ_DECLARE_PRECISION(T,rank)                  \
+    template<>                                        \
+    struct precision_trait< T > {                     \
+        static const int precisionRank = rank;        \
+        static const bool knowPrecisionRank = true;   \
+    };
+
+BZ_DECLARE_PRECISION(int,100)
+BZ_DECLARE_PRECISION(unsigned int,200)
+BZ_DECLARE_PRECISION(long,300)
+BZ_DECLARE_PRECISION(unsigned long,400)
+BZ_DECLARE_PRECISION(float,500)
+BZ_DECLARE_PRECISION(double,600)
+BZ_DECLARE_PRECISION(long double,700)
+
+#ifdef BZ_HAVE_COMPLEX
+BZ_DECLARE_PRECISION(complex<float>,800)
+BZ_DECLARE_PRECISION(complex<double>,900)
+BZ_DECLARE_PRECISION(complex<long double>,1000)
+#endif
+
+template<typename T>
+struct autopromote_trait {
+    typedef T T_numtype;
+};
+
+#define BZ_DECLARE_AUTOPROMOTE(T1,T2)     \
+    template<>                            \
+    struct autopromote_trait<T1> {        \
+      typedef T2 T_numtype;               \
+    };
+
+// These are the odd cases where small integer types
+// are automatically promoted to int or unsigned int for
+// arithmetic.
+BZ_DECLARE_AUTOPROMOTE(bool, int)
+BZ_DECLARE_AUTOPROMOTE(char, int)
+BZ_DECLARE_AUTOPROMOTE(unsigned char, int)
+BZ_DECLARE_AUTOPROMOTE(short int, int)
+BZ_DECLARE_AUTOPROMOTE(short unsigned int, unsigned int)
+
+template<typename T1, typename T2, bool promoteToT1>
+struct _bz_promote2 {
+    typedef T1 T_promote;
+};
+
+template<typename T1, typename T2>
+struct _bz_promote2<T1,T2,false> {
+    typedef T2 T_promote;
+};
+
+template<typename T1_orig, typename T2_orig>
+struct promote_trait {
+    // Handle promotion of small integers to int/unsigned int
+    typedef _bz_typename autopromote_trait<T1_orig>::T_numtype T1;
+    typedef _bz_typename autopromote_trait<T2_orig>::T_numtype T2;
+
+    // True if T1 is higher ranked
+    static const bool
+        T1IsBetter =
+            precision_trait<T1>::precisionRank >
+            precision_trait<T2>::precisionRank;
+
+    // True if we know ranks for both T1 and T2
+    static const bool
+        knowBothRanks =
+            precision_trait<T1>::knowPrecisionRank && 
+            precision_trait<T2>::knowPrecisionRank;
+
+    // True if we know T1 but not T2
+    static const bool
+        knowT1butNotT2 =  
+            precision_trait<T1>::knowPrecisionRank && 
+            !precision_trait<T2>::knowPrecisionRank;
+
+    // True if we know T2 but not T1
+    static const bool
+        knowT2butNotT1 =  
+            precision_trait<T2>::knowPrecisionRank && 
+            !precision_trait<T1>::knowPrecisionRank;
+
+    // True if T1 is bigger than T2
+    static const bool
+        T1IsLarger = sizeof(T1) >= sizeof(T2);
+
+    // We know T1 but not T2: false
+    // We know T2 but not T1: true
+    // Otherwise, if T1 is bigger than T2: true
+//     static const bool
+//         defaultPromotion = knowT1butNotT2 ? false : 
+//             (knowT2butNotT1 ? true : T1IsLarger);
+
+    // If we have both ranks, then use them.
+    // If we have only one rank, then use the unknown type.
+    // If we have neither rank, then promote to the larger type.
+    static const bool
+        promoteToT1 = knowBothRanks ? T1IsBetter : (knowT1butNotT2 ? false : 
+            (knowT2butNotT1 ? true : T1IsLarger));
+//     static const bool
+//         promoteToT1 = knowBothRanks ? T1IsBetter : defaultPromotion;
+
+    typedef _bz_typename _bz_promote2<T1,T2,promoteToT1>::T_promote T_promote;
+};
+
+#else  // !BZ_HAVE_PARTIAL_SPECIALIZATION
+
+  // No partial specialization -- have to do it the ugly way.
+  #include <blitz/promote-old.h>
+
+#endif // !BZ_HAVE_PARTIAL_SPECIALIZATION
+
+BZ_NAMESPACE_END
+
+#endif // BZ_PROMOTE_H
Index: /XMLIO_V2/external/include/blitz/rand-dunif.h
===================================================================
--- /XMLIO_V2/external/include/blitz/rand-dunif.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/rand-dunif.h	(revision 73)
@@ -0,0 +1,71 @@
+/***************************************************************************
+ * blitz/rand-dunif.h    Discrete uniform generator
+ *
+ * $Id: rand-dunif.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RAND_DUNIF_H
+#define BZ_RAND_DUNIF_H
+
+#ifndef BZ_RANDOM_H
+ #include <blitz/random.h>
+#endif
+
+#ifndef BZ_RAND_UNIFORM_H
+ #include <blitz/rand-uniform.h>
+#endif
+
+#include <math.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_uniform BZ_TEMPLATE_DEFAULT(Uniform)>
+class DiscreteUniform {
+
+public:
+    typedef int T_numtype;
+    typedef P_uniform T_uniform;
+
+    DiscreteUniform(int low, int high, double=0)
+        : low_(low), range_(high-low+1)
+    { 
+    }
+
+    void randomize() 
+    { 
+        uniform_.randomize();
+    }
+  
+    int random()
+    { 
+        return int(uniform_.random() * range_ + low_);
+    } 
+
+private:
+    int low_, range_;
+    T_uniform uniform_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RAND_DUNIF_H
+
Index: /XMLIO_V2/external/include/blitz/rand-mt.h
===================================================================
--- /XMLIO_V2/external/include/blitz/rand-mt.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/rand-mt.h	(revision 73)
@@ -0,0 +1,167 @@
+/* A C-program for MT19937: Integer version (1998/4/6)            */
+/*  genrand() generates one pseudorandom unsigned integer (32bit) */
+/* which is uniformly distributed among 0 to 2^32-1  for each     */
+/* call. sgenrand(seed) set initial values to the working area    */
+/* of 624 words. Before genrand(), sgenrand(seed) must be         */
+/* called once. (seed is any 32-bit integer except for 0).        */
+/*   Coded by Takuji Nishimura, considering the suggestions by    */
+/* Topher Cooper and Marc Rieffel in July-Aug. 1997.              */
+
+/* This library is free software; you can redistribute it and/or   */
+/* modify it under the terms of the GNU Library General Public     */
+/* License as published by the Free Software Foundation; either    */
+/* version 2 of the License, or (at your option) any later         */
+/* version.                                                        */
+/* This library is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of  */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.            */
+/* See the GNU Library General Public License for more details.    */
+/* You should have received a copy of the GNU Library General      */
+/* Public License along with this library; if not, write to the    */
+/* Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA   */ 
+/* 02111-1307  USA                                                 */
+
+/* Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura.       */
+/* When you use this, send an email to: matumoto@math.keio.ac.jp   */
+/* with an appropriate reference to your work.                     */
+
+/* REFERENCE                                                       */
+/* M. Matsumoto and T. Nishimura,                                  */
+/* "Mersenne Twister: A 623-Dimensionally Equidistributed Uniform  */
+/* Pseudo-Random Number Generator",                                */
+/* ACM Transactions on Modeling and Computer Simulation,           */
+/* Vol. 8, No. 1, January 1998, pp 3--30.                          */
+
+// See http://www.math.keio.ac.jp/~matumoto/emt.html
+
+// 1999-01-25 adapted to STL-like idiom
+// allan@stokes.ca (Allan Stokes) www.stokes.ca
+
+#ifndef BZ_RAND_MT
+#define BZ_RAND_MT
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#include <vector>
+
+BZ_NAMESPACE(blitz)
+
+// decomposition issues:
+//   machine representation of integer types
+//   output buffer option verses inline post-conditioning
+
+class MersenneTwister
+{
+private:
+  typedef unsigned int twist_int; // must be at least 32 bits
+                                  // larger might be faster
+  typedef vector<twist_int> State;
+  typedef State::iterator Iter;
+
+  struct BitMixer {
+    enum { K = 0x9908b0df };
+    BitMixer() : s0(0) {}
+    inline friend twist_int low_mask (twist_int s1) {
+      return (s1&1u) ? K : 0u;
+    }
+    inline twist_int high_mask (twist_int s1) const {
+      return ((s0&0x80000000)|(s1&0x7fffffff))>>1;
+    }
+    inline twist_int operator() (twist_int s1) {
+      twist_int r = high_mask(s1) ^ low_mask(s1);
+      s0 = s1;
+      return r;
+    }
+    twist_int s0;
+  };
+
+enum { N = 624, PF = 397, reference_seed = 4357 }; 
+  
+public: 
+  MersenneTwister () {} // S empty will trigger auto-seed
+
+  void seed (twist_int seed = reference_seed)
+  {
+    if (!S.size()) S.resize(N);
+    enum { Knuth_A = 69069 }; 
+    twist_int x = seed & 0xFFFFFFFF;
+    Iter s = S.begin();
+    twist_int mask = (seed == reference_seed) ? 0 : 0xFFFFFFFF;
+    for (int j = 0; j < N; ++j) {
+      // adding j here avoids the risk of all zeros 
+      // we suppress this term in "compatibility" mode  
+      *s++ = (x + (mask & j)) & 0xFFFFFFFF; 
+      x *= Knuth_A;
+    }
+    reload();
+  }
+
+  void reload (void)
+  {
+    if (!S.size()) seed (); // auto-seed detection
+
+    Iter p0 = S.begin();
+    Iter pM = p0 + PF;
+    BitMixer twist;
+    twist (S[0]); // prime the pump
+    for (Iter pf_end = S.begin()+(N-PF); p0 != pf_end; ++p0, ++pM)
+      *p0 = *pM ^ twist (p0[1]);
+    pM = S.begin();
+    for (Iter s_end = S.begin()+(N-1); p0 != s_end; ++p0, ++pM)
+      *p0 = *pM ^ twist (p0[1]);
+    *p0 = *pM ^ twist (S[0]);
+
+    I = S.begin();
+  }
+
+  inline twist_int random (void)
+  {
+    if (I >= S.end()) reload();
+    twist_int y = *I++;
+    y ^= (y >> 11);
+    y ^= (y <<  7) & 0x9D2C5680;
+    y ^= (y << 15) & 0xEFC60000;
+    y ^= (y >> 18);
+    return y;
+  }
+
+private:
+  State   S;
+  Iter    I;
+};
+
+
+// This version returns a double in the range [0,1).
+
+class MersenneTwisterDouble {
+
+public:
+  MersenneTwisterDouble()
+  {
+      // f = 1/(2^32);
+      f = (1.0 / 65536) / 65536;
+  }
+
+  void randomize(unsigned int seed)
+  {
+      gen_.seed(seed);
+  }
+
+  double random()
+  {
+      unsigned long y1 = gen_.random();
+      unsigned long y2 = gen_.random();
+
+      return ((y1 * f) * y2 * f);
+  }
+
+private:
+  MersenneTwister gen_;
+  double f;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RAND_MT
Index: /XMLIO_V2/external/include/blitz/rand-normal.h
===================================================================
--- /XMLIO_V2/external/include/blitz/rand-normal.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/rand-normal.h	(revision 73)
@@ -0,0 +1,89 @@
+/***************************************************************************
+ * blitz/rand-normal.h    Random Gaussian (Normal) generator
+ *
+ * $Id: rand-normal.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************
+ *
+ * This generator transforms a (0,1] uniform distribution into
+ * a Normal distribution.  Let u,v be (0,1] random variables. Then
+ *
+ *    x = sqrt(-2 ln v) cos(pi (2u-1))
+ *
+ * is N(0,1) distributed.
+ *
+ * Reference: Athanasios Papoulis, "Probability, random variables,
+ * and stochastic processes," McGraw-Hill : Toronto, 1991.
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RAND_NORMAL_H
+#define BZ_RAND_NORMAL_H
+
+#ifndef BZ_RANDOM_H
+ #include <blitz/random.h>
+#endif
+
+#ifndef BZ_RAND_UNIFORM_H
+ #include <blitz/rand-uniform.h>
+#endif
+
+#include <math.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_uniform BZ_TEMPLATE_DEFAULT(Uniform)>
+class Normal {
+
+public:
+    typedef double T_numtype;
+
+    Normal(double mean = 0.0, double variance = 1.0, double = 0.0)
+        : mean_(mean), sigma_(::sqrt(variance))
+    { 
+    }
+
+    void randomize() 
+    { 
+        uniform_.randomize();
+    }
+  
+    double random()
+    { 
+        double u, v;
+
+        do {
+            u = uniform_.random();
+            v = uniform_.random();    
+        } while (v == 0);
+
+        return mean_ + sigma_ * ::sqrt(-2*::log(v)) * ::cos(M_PI * (2*u - 1));
+    } 
+
+private:
+    double mean_, sigma_;
+    P_uniform uniform_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RAND_NORMAL_H
+
Index: /XMLIO_V2/external/include/blitz/rand-tt800.h
===================================================================
--- /XMLIO_V2/external/include/blitz/rand-tt800.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/rand-tt800.h	(revision 73)
@@ -0,0 +1,122 @@
+/***************************************************************************
+ * blitz/rand-tt800.h      Matsumoto and Kurita's TT800 uniform random 
+ *                         number generator.
+ *
+ * $Id: rand-tt800.h,v 1.2 2003/01/14 11:29:18 patricg Exp $
+ *
+ ***************************************************************************
+ *
+ * The class TT800 encapsulates Makoto Matsumoto and Yoshiharu Kurita's 
+ * TT800 twisted generalized feedback shift register (TGFSR) random number 
+ * generator.  The generator has period 2^800 - 1.
+ *
+ * Contact: M. Matsumoto <matumoto@math.keio.ac.jp>
+ *
+ * See: M. Matsumoto and Y. Kurita, Twisted GFSR Generators II, 
+ *      ACM Transactions on Modelling and Computer Simulation,
+ *      Vol. 4, No. 3, 1994, pages 254-266.
+ *
+ * (c) 1994 Association for Computing Machinery.  
+ *
+ * Distributed with consent of the authors.
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RAND_TT800_H
+#define BZ_RAND_TT800_H
+
+#ifndef BZ_RANDOM_H
+ #include <blitz/random.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+class TT800 {
+
+public:
+    typedef double T_numtype;
+
+    TT800(double low = 0.0, double high = 1.0, double = 0.0)
+        : low_(low), length_(high-low)
+    { 
+        // Initial 25 seeds
+        x[0] = 0x95f24dab; x[1] = 0x0b685215; x[2] = 0xe76ccae7;
+        x[3] = 0xaf3ec239; x[4] = 0x715fad23; x[5] = 0x24a590ad;
+        x[6] = 0x69e4b5ef; x[7] = 0xbf456141; x[8] = 0x96bc1b7b;
+        x[9] = 0xa7bdf825; x[10] = 0xc1de75b7; x[11] = 0x8858a9c9;
+        x[12] = 0x2da87693; x[13] = 0xb657f9dd; x[14] = 0xffdc8a9f;
+        x[15] = 0x8121da71; x[16] = 0x8b823ecb; x[17] = 0x885d05f5;
+        x[18] = 0x4e20cd47; x[19] = 0x5a9ad5d9; x[20] = 0x512c0c03;
+        x[21] = 0xea857ccd; x[22] = 0x4cc1d30f; x[23] = 0x8891a8a1;
+        x[24] = 0xa6b7aadb;
+
+        // Magic vector 'a', don't change
+        mag01[0] = 0;
+        mag01[1] = 0x8ebfd028;
+
+        k = 0;
+
+        // f = 1/(2^32);
+
+        f = (1.0 / 65536) / 65536;
+    }
+
+    void randomize() 
+    { 
+        BZ_NOT_IMPLEMENTED();            // NEEDS_WORK
+    }
+ 
+    unsigned long randomUint32()
+    {
+        if (k==N)
+            generate();
+
+        unsigned long y = x[k];
+        y ^= (y << 7) & 0x2b5b2500; /* s and b, magic vectors */
+        y ^= (y << 15) & 0xdb8b0000; /* t and c, magic vectors */
+        y &= 0xffffffff; /* you may delete this line if word size = 32 */
+
+        // the following line was added by Makoto Matsumoto in the 1996 version
+        // to improve lower bit's corellation.
+        // Delete this line to use the code published in 1994.
+
+        y ^= (y >> 16); /* added to the 1994 version */
+        k++;
+    }
+ 
+    double random()
+    { 
+        unsigned long y1 = randomUint32();
+        unsigned long y2 = randomUint32();
+
+        return low_ + length_ * ((y1 * f) * y2 * f);
+    } 
+
+protected:
+    void generate()
+    {
+        /* generate N words at one time */
+        int kk;
+        for (kk=0;kk<N-M;kk++) {
+            x[kk] = x[kk+M] ^ (x[kk] >> 1) ^ mag01[x[kk] % 2];
+        }
+        for (; kk<N;kk++) {
+            x[kk] = x[kk+(M-N)] ^ (x[kk] >> 1) ^ mag01[x[kk] % 2];
+        }
+        k=0;
+    }
+
+private:
+    enum { N = 25, M = 7 };
+
+    double low_, length_;
+    double f;
+    int k;
+    unsigned long x[N];
+    unsigned long mag01[2];
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RAND_TT800_H
+
Index: /XMLIO_V2/external/include/blitz/rand-uniform.h
===================================================================
--- /XMLIO_V2/external/include/blitz/rand-uniform.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/rand-uniform.h	(revision 73)
@@ -0,0 +1,116 @@
+/***************************************************************************
+ * blitz/rand-uniform.h    Uniform class, which provides uniformly
+ *                         distributed random numbers.
+ *
+ * $Id: rand-uniform.h,v 1.3 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************
+ *
+ * This random number generator is based on the LAPACK auxilliary
+ * routine DLARAN by Jack Dongarra.  It's a multiplicative congruential 
+ * generator with modulus 2^48 and multiplier 33952834046453. 
+ *
+ * See also: G. S. Fishman, Multiplicative congruential random number
+ * generators with modulus 2^b: an exhaustive analysis for b=32 and
+ * a partial analysis for b=48, Math. Comp. 189, pp 331-344, 1990.
+ * 
+ * This routine requires 32-bit integers.
+ *
+ * The generated number lies in the open interval (low,high).  i.e. low and
+ * high themselves will never be generated.
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RAND_UNIFORM_H
+#define BZ_RAND_UNIFORM_H
+
+#ifndef BZ_RANDOM_H
+ #include <blitz/random.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+class Uniform {
+
+public:
+    typedef double T_numtype;
+
+    Uniform(double low = 0.0, double high = 1.0, double = 0.0)
+        : low_(low), length_(high-low)
+    { 
+        BZPRECONDITION(sizeof(int) >= 4);   // Need 32 bit integers!
+
+        seed[0] = 24;       // All seeds in the range [0,4095]
+        seed[1] = 711;
+        seed[2] = 3;
+        seed[3] = 3721;     // The last seed must be odd
+    }
+
+    void randomize() 
+    { 
+        BZ_NOT_IMPLEMENTED();            // NEEDS_WORK
+
+        BZPOSTCONDITION(seed[3] % 2 == 1);
+    }
+  
+    // I'm trying to avoid having a compiled 
+    // portion of the library, so this is inline until I
+    // figure out a better way to do this or I change my mind.
+    // -- TV
+    // NEEDS_WORK
+    double random()
+    { 
+        BZPRECONDITION(seed[3] % 2 == 1);
+
+        int it0, it1, it2, it3;
+        it3 = seed[3] * 2549;
+        it2 = it3 / 4096;
+        it3 -= it2 << 12;
+        it2 += seed[2] * 2549 + seed[3] * 2508;
+        it1 = it2 / 4096;
+        it2 -= it1 << 12;
+        it1 += seed[1] * 2549 + seed[2] * 2508 + seed[3] * 322;
+        it0 = it1 / 4096;
+        it1 -= it0 << 12;
+        it0 += seed[0] * 2549 + seed[1] * 2508 + seed[2] * 322 + seed[3] * 494;
+        it0 %= 4096;
+        seed[0] = it0;
+        seed[1] = it1;
+        seed[2] = it2;
+        seed[3] = it3;
+      
+        const double z = 1 / 4096.;
+        return low_ + length_ * (it0 + (it1 + (it2 + it3 * z) * z) * z) * z;
+    } 
+
+    operator double() 
+    { return random(); }
+
+private:
+    double low_, length_;
+
+    int seed[4];
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RAND_UNIFORM_H
+
Index: /XMLIO_V2/external/include/blitz/random.h
===================================================================
--- /XMLIO_V2/external/include/blitz/random.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/random.h	(revision 73)
@@ -0,0 +1,64 @@
+/***************************************************************************
+ * blitz/random.h       Random number generator wrapper class
+ *
+ * $Id: random.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RANDOM_H
+#define BZ_RANDOM_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_distribution>
+class Random {
+
+public:
+    typedef P_distribution T_distribution;
+    typedef _bz_typename T_distribution::T_numtype T_numtype;
+
+    Random(double parm1=0.0, double parm2=1.0, double parm3=0.0)
+        : generator_(parm1, parm2, parm3)
+    { }
+
+    void randomize()
+    { generator_.randomize(); }
+   
+    T_numtype random()
+    { return generator_.random(); }
+
+    operator T_numtype()
+    { return generator_.random(); }
+
+protected: 
+    T_distribution generator_;
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/randref.h>
+
+#endif // BZ_RANDOM_H
+
Index: /XMLIO_V2/external/include/blitz/randref.h
===================================================================
--- /XMLIO_V2/external/include/blitz/randref.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/randref.h	(revision 73)
@@ -0,0 +1,79 @@
+/***************************************************************************
+ * blitz/randref.h      Random number generators, expression templates
+ *                      wrapper
+ *
+ * $Id: randref.h,v 1.5 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RANDREF_H
+#define BZ_RANDREF_H
+
+#ifndef BZ_RANDOM_H
+ #error <blitz/randref.h> must be included via <blitz/random.h>
+#endif // BZ_RANDOM_H
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_distribution>
+class _bz_VecExprRandom {
+
+public:
+    typedef _bz_typename Random<P_distribution>::T_numtype T_numtype;
+
+    _bz_VecExprRandom(Random<P_distribution>& random)
+        : random_(random)
+    { }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecExprRandom(_bz_VecExprRandom<P_distribution>& x)
+        : random_(x.random_)
+    { }
+#endif
+
+    T_numtype operator[](unsigned) const
+    { return random_.random(); }
+
+    T_numtype operator()(unsigned) const
+    { return random_.random(); }
+
+    unsigned length(unsigned recommendedLength) const
+    { return recommendedLength; }
+
+    unsigned _bz_suggestLength() const
+    { return 0; }
+
+    bool _bz_hasFastAccess() const
+    { return 1; }
+
+    T_numtype _bz_fastAccess(unsigned) const
+    { return random_.random(); }
+
+private:
+    _bz_VecExprRandom() : random_( Random<P_distribution>() ) { }
+
+    Random<P_distribution>& random_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RANDREF_H
+
Index: /XMLIO_V2/external/include/blitz/range.h
===================================================================
--- /XMLIO_V2/external/include/blitz/range.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/range.h	(revision 73)
@@ -0,0 +1,210 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/range.h      Declaration of the Range class
+ *
+ * $Id: range.h,v 1.9 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_RANGE_H
+#define BZ_RANGE_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_VECEXPRWRAP_H
+ #include <blitz/vecexprwrap.h>      // _bz_VecExpr wrapper
+#endif
+
+#include <blitz/wrap-climits.h>                  // for INT_MIN
+
+BZ_NAMESPACE(blitz)
+
+// Examples: 
+// Vector<double> x(7);
+// Range::all()                    [0,1,2,3,4,5,6]
+// Range(3,5)                      [3,4,5]
+// Range(3,Range::toEnd)           [3,4,5,6]
+// Range(Range::fromStart,3)       [0,1,2,3]
+// Range(1,5,2);                   [1,3,5]
+
+enum { fromStart = INT_MIN, toEnd = INT_MIN };
+
+// Class Range
+class Range {
+
+public:
+    // This declaration not yet supported by all compilers
+    // const int fromStart = INT_MIN;
+    // const int toEnd = INT_MIN;
+
+    typedef int T_numtype;
+
+    enum { fromStart = INT_MIN, toEnd = INT_MIN };
+
+    Range()
+    {
+        first_ = fromStart;
+        last_ = toEnd;
+        stride_ = 1;
+    }
+
+    // Range(Range r): allow default copy constructor to be used
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    Range(const Range& r)
+    {
+        first_ = r.first_;
+        last_ = r.last_;
+        stride_ = r.stride_;
+    }
+#endif
+
+    explicit Range(int slicePosition)
+    {
+        first_ = slicePosition;
+        last_ = slicePosition;
+        stride_ = 1;
+    }
+
+    Range(int first, int last, int stride=1)
+        : first_(first), last_(last), stride_(stride)
+    { 
+        BZPRECHECK((first == fromStart) || (last == toEnd) ||
+                       (first < last) && (stride > 0) ||
+                       (first > last) && (stride < 0) ||
+                       (first == last), (*this) << " is an invalid range.");
+        BZPRECHECK((last-first) % stride == 0,
+            (*this) << ": the stride must evenly divide the range");
+    }
+
+    int first(int lowRange = 0) const
+    { 
+        if (first_ == fromStart)
+            return lowRange;
+        return first_; 
+    }
+
+    int last(int highRange = 0) const
+    {
+        if (last_ == toEnd)
+            return highRange;
+        return last_;
+    }
+
+    unsigned length(int =0) const
+    {
+        BZPRECONDITION(first_ != fromStart);
+        BZPRECONDITION(last_ != toEnd);
+        BZPRECONDITION((last_ - first_) % stride_ == 0);
+        return (last_ - first_) / stride_ + 1;
+    }
+
+    int stride() const
+    { return stride_; }
+
+    bool isAscendingContiguous() const
+    {
+        return ((first_ < last_) && (stride_ == 1) || (first_ == last_));
+    }
+
+    void setRange(int first, int last, int stride=1)
+    {
+        BZPRECONDITION((first < last) && (stride > 0) ||
+                       (first > last) && (stride < 0) ||
+                       (first == last));
+        BZPRECONDITION((last-first) % stride == 0);
+        first_ = first;
+        last_ = last;
+        stride_ = stride;
+    }
+
+    static Range all() 
+    { return Range(fromStart,toEnd,1); }
+
+    bool isUnitStride() const
+    { return stride_ == 1; }
+
+    // Operators
+    Range operator-(int shift) const
+    { 
+        BZPRECONDITION(first_ != fromStart);
+        BZPRECONDITION(last_ != toEnd);
+        return Range(first_ - shift, last_ - shift, stride_); 
+    }
+
+    Range operator+(int shift) const
+    { 
+        BZPRECONDITION(first_ != fromStart);
+        BZPRECONDITION(last_ != toEnd);
+        return Range(first_ + shift, last_ + shift, stride_); 
+    }
+
+    int operator[](unsigned i) const
+    {
+        return first_ + i * stride_;
+    }
+
+    int operator()(unsigned i) const
+    {
+        return first_ + i * stride_;
+    }
+
+    friend inline ostream& operator<<(ostream& os, const Range& range)
+    {
+        os << "Range(" << range.first() << "," << range.last() << ","
+           << range.stride() << ")";
+
+        return os;
+    }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    static const int
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 0,
+        _bz_staticLength = 0;
+
+    bool _bz_hasFastAccess() const
+    { return stride_ == 1; }
+
+    T_numtype _bz_fastAccess(unsigned i) const
+    { return first_ + i; }
+
+    unsigned _bz_suggestLength() const
+    { 
+        return length();
+    }
+
+    _bz_VecExpr<Range> _bz_asVecExpr() const
+    { return _bz_VecExpr<Range>(*this); }
+
+private:
+    int first_, last_, stride_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_RANGE_H
Index: /XMLIO_V2/external/include/blitz/reduce.h
===================================================================
--- /XMLIO_V2/external/include/blitz/reduce.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/reduce.h	(revision 73)
@@ -0,0 +1,793 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/reduce.h        Reduction operators: sum, mean, min, max,
+ *                       minIndex, maxIndex, product, count, any, all
+ *
+ * $Id: reduce.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_REDUCE_H
+#define BZ_REDUCE_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_NUMTRAIT_H
+ #include <blitz/numtrait.h>
+#endif
+
+#ifndef BZ_NUMINQUIRE_H
+ #include <blitz/numinquire.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_sourcetype, typename P_resulttype = BZ_SUMTYPE(P_sourcetype)>
+class ReduceSum {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef P_resulttype T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = true;
+
+    ReduceSum()
+    { reset(); }
+
+    ReduceSum(T_resulttype initialValue)
+    { sum_ = initialValue; }
+
+    bool operator()(T_sourcetype x)
+    { 
+        sum_ += x; 
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    { 
+        sum_ += x; 
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return sum_; }
+
+    void reset()
+    { sum_ = zero(T_resulttype()); }
+
+    void reset(T_resulttype initialValue)
+    { sum_ = initialValue; }
+ 
+    static const char* name()
+    { return "sum"; }
+ 
+protected:
+    T_resulttype sum_;
+};
+
+template<typename P_sourcetype, typename P_resulttype = BZ_FLOATTYPE(P_sourcetype)>
+class ReduceMean {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef P_resulttype T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = false;
+
+    ReduceMean()
+    { reset(); }
+
+    ReduceMean(T_resulttype)
+    { 
+        BZPRECHECK(0, "Provided an initial value for ReduceMean");
+        reset();
+    }
+
+    bool operator()(T_sourcetype x)
+    { 
+        sum_ += x; 
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    { 
+        sum_ += x; 
+        return true;
+    }
+
+    T_resulttype result(int count)
+    { return sum_ / count; }
+
+    void reset()
+    { sum_ = zero(T_resulttype()); }
+
+    void reset(T_resulttype)
+    { 
+        BZPRECHECK(0, "Provided an initial value for ReduceMean");
+        reset();
+    }
+
+    static const char* name() 
+    { return "mean"; }
+
+protected:
+    T_resulttype sum_;
+};
+
+template<typename P_sourcetype>
+class ReduceMin {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef P_sourcetype T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = false;
+
+    ReduceMin()
+    { reset(); }
+
+    ReduceMin(T_resulttype min)
+    {
+        min_ = min;
+    }
+
+    bool operator()(T_sourcetype x)
+    { 
+        if (x < min_)
+            min_ = x;
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    {
+        if (x < min_)
+            min_ = x;
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return min_; }
+
+    void reset()
+    { min_ = huge(P_sourcetype()); }
+
+    void reset(T_resulttype initialValue)
+    { min_ = initialValue; }
+
+    static const char* name()
+    { return "min"; }
+
+protected:
+    T_resulttype min_;
+};
+
+template<typename P_sourcetype>
+class ReduceMax {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef P_sourcetype T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = true;
+
+    ReduceMax()
+    { reset(); }
+
+    ReduceMax(T_resulttype max)
+    {
+        max_ = max;
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        if (x > max_)
+            max_ = x;
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    {
+        if (x > max_)
+            max_ = x;
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return max_; }
+
+    void reset()
+    { max_ = neghuge(P_sourcetype()); }
+
+    void reset(T_resulttype initialValue)
+    { max_ = initialValue; }
+
+    static const char* name()
+    { return "max"; }
+
+protected:
+    T_resulttype max_;
+};
+
+template<typename P_sourcetype>
+class ReduceMinIndex {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef int          T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = true, canProvideInitialValue = false;
+
+    ReduceMinIndex()
+    { reset(); }
+
+    ReduceMinIndex(T_resulttype min)
+    {
+        reset(min);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype x, int index)
+    {
+        if (x < min_)
+        {
+            min_ = x;
+            index_ = index;
+        }
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    { 
+        min_ = huge(T_sourcetype());
+        index_ = tiny(int());        
+    }
+
+    void reset(T_resulttype)
+    { 
+        BZPRECHECK(0, "Provided initial value for ReduceMinIndex");
+        reset();
+    }
+
+    static const char* name()
+    { return "minIndex"; }
+
+protected:
+    T_sourcetype min_;
+    int index_;
+};
+
+template<typename P_sourcetype, int N>
+class ReduceMinIndexVector {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef TinyVector<int,N> T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool canProvideInitialValue = false;
+
+    ReduceMinIndexVector()
+    { reset(); }
+
+    ReduceMinIndexVector(T_resulttype min)
+    {
+        reset(min);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype, int)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+   
+    bool operator()(T_sourcetype x, const TinyVector<int,N>& index)
+    {
+        if (x < min_)
+        {
+            min_ = x;
+            index_ = index;
+        }
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    {
+        min_ = huge(T_sourcetype());
+        index_ = tiny(int());
+    }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceMinIndex");
+        reset();
+    }
+
+    static const char* name()
+    { return "minIndex"; }
+
+protected:
+    T_sourcetype min_;
+    TinyVector<int,N> index_;
+};
+
+template<typename P_sourcetype>
+class ReduceMaxIndex {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef int          T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = true, canProvideInitialValue = false;
+
+    ReduceMaxIndex()
+    { reset(); }
+
+    ReduceMaxIndex(T_resulttype max)
+    {
+        reset(max);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype x, int index)
+    {
+        if (x > max_)
+        {
+            max_ = x;
+            index_ = index;
+        }
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    {
+        max_ = neghuge(T_sourcetype());
+        index_ = tiny(int());
+    }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceMaxIndex");
+        reset();
+    }
+
+    static const char* name()
+    { return "maxIndex"; }
+
+protected:
+    T_sourcetype max_;
+    int index_;
+};
+
+template<typename P_sourcetype, int N_rank>
+class ReduceMaxIndexVector {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef TinyVector<int,N_rank> T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool canProvideInitialValue = false;
+
+    ReduceMaxIndexVector()
+    { reset(); }
+
+    ReduceMaxIndexVector(T_resulttype max)
+    {
+        reset(max);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype x, const TinyVector<int,N_rank>& index)
+    {
+        if (x > max_)
+        {
+            max_ = x;
+            index_ = index;
+        }
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    {
+        max_ = neghuge(T_sourcetype());
+        index_ = tiny(int());
+    }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceMaxIndex");
+        reset();
+    }
+
+    static const char* name()
+    { return "maxIndex"; }
+
+protected:
+    T_sourcetype max_;
+    TinyVector<int,N_rank> index_;
+};
+
+template<typename P_sourcetype>
+class ReduceFirst {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef int          T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = true, canProvideInitialValue = false;
+
+    ReduceFirst()
+    { reset(); }
+
+    ReduceFirst(T_resulttype)
+    {
+        BZPRECONDITION(0);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype x, int index)
+    {
+        if (x)
+        {
+            index_ = index;
+            return false;
+        }
+        else
+            return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    {
+        index_ = tiny(int());
+    }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceFirst");
+        reset();
+    }
+
+    static const char* name()
+    { return "first"; }
+
+protected:
+    int index_;
+};
+
+template<typename P_sourcetype>
+class ReduceLast {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef int          T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = true, canProvideInitialValue = false;
+
+    ReduceLast()
+    { reset(); }
+
+    ReduceLast(T_resulttype)
+    {
+        BZPRECONDITION(0);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        BZPRECONDITION(0);
+        return false;
+    }
+
+    bool operator()(T_sourcetype x, int index)
+    {
+        if (x)
+        {
+            index_ = index;
+            return true;
+        }
+        else
+            return true;
+    }
+
+    T_resulttype result(int)
+    { return index_; }
+
+    void reset()
+    {
+        index_ = huge(int());
+    }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceFirst");
+        reset();
+    }
+
+    static const char* name()
+    { return "last"; }
+
+protected:
+    int index_;
+};
+
+template<typename P_sourcetype, typename P_resulttype = BZ_SUMTYPE(P_sourcetype)>
+class ReduceProduct {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef P_resulttype T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = true;
+
+    ReduceProduct()
+    { product_ = one(T_resulttype()); }
+
+    ReduceProduct(T_resulttype initialValue)
+    { product_ = initialValue; }
+
+    bool operator()(T_sourcetype x)
+    { 
+        product_ *= x; 
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    { 
+        product_ *= x; 
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return product_; }
+
+    void reset()
+    { product_ = one(T_resulttype()); }
+
+    void reset(T_resulttype initialValue)
+    { product_ = initialValue; }
+
+    static const char* name()
+    { return "product"; }
+
+protected:
+    T_resulttype product_;
+};
+
+template<typename P_sourcetype>
+class ReduceCount {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef int          T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = true;
+
+    ReduceCount()
+    { reset(); }
+
+    ReduceCount(T_resulttype count)
+    {
+        count_ = count;
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        if (x)
+            ++count_;
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    {
+        if (x)
+            ++count_;
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return count_; }
+
+    void reset()
+    { count_ = zero(T_resulttype()); }
+
+    void reset(T_resulttype initialValue)
+    { count_ = initialValue; }
+
+    static const char* name()
+    { return "count"; }
+
+protected:
+    T_resulttype count_;
+};
+
+template<typename P_sourcetype>
+class ReduceAny {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef bool     T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = false;
+
+    ReduceAny()
+    { reset(); }
+
+    ReduceAny(T_resulttype initialValue)
+    {
+        reset(initialValue);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        if (x)
+        {
+            any_ = true;
+            return false;
+        }
+
+        return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    {
+        if (x)
+        {
+            any_ = true;
+            return false;
+        }
+
+        return true;
+    }
+
+    T_resulttype result(int)
+    { return any_; }
+
+    void reset()
+    { any_ = false; }
+
+    void reset(T_resulttype)
+    { 
+        BZPRECHECK(0, "Provided initial value for ReduceAny");
+        reset();
+    }
+
+    static const char* name()
+    { return "any"; }
+
+protected:
+    T_resulttype any_;
+};
+
+template<typename P_sourcetype>
+class ReduceAll {
+
+public:
+    typedef P_sourcetype T_sourcetype;
+    typedef bool     T_resulttype;
+    typedef T_resulttype T_numtype;
+
+    static const bool needIndex = false, canProvideInitialValue = false;
+
+    ReduceAll()
+    { reset(); }
+
+    ReduceAll(T_resulttype initialValue)
+    {
+        reset(initialValue);
+    }
+
+    bool operator()(T_sourcetype x)
+    {
+        if (!bool(x))
+        {
+            all_ = false;
+            return false;
+        }
+        else
+            return true;
+    }
+
+    bool operator()(T_sourcetype x, int)
+    {
+        if (!bool(x))
+        {
+            all_ = false;
+            return false;
+        }
+        else
+            return true;
+    }
+
+    T_resulttype result(int)
+    { return all_; }
+
+    void reset()
+    { all_ = true; }
+
+    void reset(T_resulttype)
+    {
+        BZPRECHECK(0, "Provided initial value for ReduceAll");
+        reset();
+    }
+
+    static const char* name()
+    { return "all"; }
+
+protected:
+    T_resulttype all_;
+}; 
+
+BZ_NAMESPACE_END
+
+#endif // BZ_REDUCE_H
Index: /XMLIO_V2/external/include/blitz/shapecheck.h
===================================================================
--- /XMLIO_V2/external/include/blitz/shapecheck.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/shapecheck.h	(revision 73)
@@ -0,0 +1,74 @@
+/***************************************************************************
+ * blitz/shapecheck.h    Functions for checking conformability of arrays
+ *
+ * $Id: shapecheck.h,v 1.5 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_SHAPECHECK_H
+#define BZ_SHAPECHECK_H
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * The function areShapesConformable(A,B) checks that the shapes 
+ * A and B are conformable (i.e. the same size/geometry).  Typically 
+ * the A and B parameters are of type TinyVector<int,N_rank> and represent 
+ * the extent of the arrays.  It's possible that in the future jagged-edged
+ * arrays will be supported, in which case shapes may be lists
+ * of subdomains.
+ */
+
+template<typename T_shape1, typename T_shape2>
+inline bool areShapesConformable(const T_shape1&, const T_shape2&)
+{
+    // If the shape objects are different types, this means
+    // that the arrays are different ranks, or one is jagged
+    // edged, etc.  In this case the two arrays are not
+    // conformable.
+    return false;
+}
+
+template<typename T_shape>
+inline bool areShapesConformable(const T_shape& a, const T_shape& b)
+{
+    // The shape objects are the same type, so compare them.
+
+    // NEEDS_WORK-- once the "all" reduction is implemented, should
+    // use it.
+    // return all(a == b);
+
+    for (unsigned i=0; i < a.length(); ++i)
+    {
+        if (a[i] != b[i])
+        {
+            BZ_DEBUG_MESSAGE("Incompatible shapes detected: " << endl 
+                 << a << endl << b << endl);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/tau.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tau.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tau.h	(revision 73)
@@ -0,0 +1,49 @@
+/***************************************************************************
+ * blitz/tau.h       Integration with the Tau profiling package.
+ *                   See http://www.acl.lanl.gov/tau/
+ *
+ * $Id: tau.h,v 1.3 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TAU_H
+#define BZ_TAU_H
+
+#ifdef BZ_TAU_PROFILING
+ #define TAU_BLITZ  TAU_USER1
+ #include <Profile/Profiler.h>
+
+#else
+ #define TYPE_STRING(profileString, str)
+ #define PROFILED_BLOCK(name, type)
+ #define TAU_TYPE_STRING(profileString, str)
+ #define TAU_PROFILE(name, type, group)
+ #define TAU_PROFILE_TIMER(var, name, type, group)
+ #define TAU_PROFILE_START(var)
+ #define TAU_PROFILE_STOP(var)
+ #define TAU_PROFILE_STMT(stmt)
+ #define TAU_PROFILE_EXIT(msg)
+ #define TAU_PROFILE_INIT(argc, argv)
+ #define TAU_PROFILE_SET_NODE(node)
+ #define CT(obj)
+#endif // ! BZ_TAU_PROFILING
+
+#endif // BZ_TAU_H
Index: /XMLIO_V2/external/include/blitz/timer.h
===================================================================
--- /XMLIO_V2/external/include/blitz/timer.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/timer.h	(revision 73)
@@ -0,0 +1,107 @@
+/***************************************************************************
+ * blitz/Timer.h        Timer class, for use in benchmarking
+ *
+ * $Id: timer.h,v 1.4 2005/10/10 22:35:30 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+// This class is not portable to non System V platforms.
+// It will need to be rewritten for Windows, NT, Mac.
+// NEEDS_WORK
+
+#ifndef BZ_TIMER_H
+#define BZ_TIMER_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifdef BZ_HAVE_RUSAGE
+ #include <sys/resource.h>
+#else
+ #include <time.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+class Timer {
+
+public:
+    Timer() 
+    { 
+        state_ = uninitialized;
+    }
+
+    void start()
+    { 
+        state_ = running;
+        t1_ = systemTime();
+    }
+
+    void stop()
+    {
+        t2_ = systemTime();
+        BZPRECONDITION(state_ == running);
+        state_ = stopped;
+    }
+    
+/* Compaq cxx compiler in ansi mode cannot print out long double type! */
+#if defined(__DECCXX)
+    double elapsedSeconds()
+#else
+    long double elapsedSeconds()
+#endif
+    {
+        BZPRECONDITION(state_ == stopped);
+        return t2_ - t1_;
+    }
+
+private:
+    Timer(Timer&) { }
+    void operator=(Timer&) { }
+
+    long double systemTime()
+    {
+#ifdef BZ_HAVE_RUSAGE
+        getrusage(RUSAGE_SELF, &resourceUsage_);
+        double seconds = resourceUsage_.ru_utime.tv_sec 
+            + resourceUsage_.ru_stime.tv_sec;
+        double micros  = resourceUsage_.ru_utime.tv_usec 
+            + resourceUsage_.ru_stime.tv_usec;
+        return seconds + micros/1.0e6;
+#else
+        return clock() / (long double) CLOCKS_PER_SEC;
+#endif
+    }
+
+    enum { uninitialized, running, stopped } state_;
+
+#ifdef BZ_HAVE_RUSAGE
+    struct rusage resourceUsage_;
+#endif
+
+    long double t1_, t2_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TIMER_H
+
Index: /XMLIO_V2/external/include/blitz/tiny.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tiny.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tiny.h	(revision 73)
@@ -0,0 +1,42 @@
+/***************************************************************************
+ * blitz/tiny.h          Tiny base class; now defunct; delete?
+ *
+ * $Id: tiny.h,v 1.3 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_TINY_H
+#define BZ_TINY_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+class _bz_tinyBase {
+};
+
+BZ_NAMESPACE_END
+
+#endif
+
Index: /XMLIO_V2/external/include/blitz/tinymat.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tinymat.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinymat.h	(revision 73)
@@ -0,0 +1,145 @@
+/***************************************************************************
+ * blitz/tinymat.h       Declaration of TinyMatrix<T, N, M>
+ *
+ * $Id: tinymat.h,v 1.6 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TINYMAT_H
+#define BZ_TINYMAT_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+#ifndef BZ_TINYVEC_H
+ #include <blitz/tinyvec.h>
+#endif
+
+#ifndef BZ_LISTINIT_H
+ #include <blitz/listinit.h>
+#endif
+
+#include <blitz/tinymatexpr.h>
+#include <blitz/meta/matassign.h>
+
+BZ_NAMESPACE(blitz)
+
+// Forward declarations
+template<typename T_expr>
+class _bz_tinyMatExpr;
+
+template<typename T_numtype, int N_rows, int N_columns, int N_rowStride,
+    int N_colStride>
+class _bz_tinyMatrixRef {
+
+public:
+    _bz_tinyMatrixRef(T_numtype* restrict const data)
+        : data_(data)
+    { }
+
+    T_numtype * restrict data()
+    { return (T_numtype * restrict)data_; }
+
+    T_numtype& restrict operator()(int i, int j)
+    { return data_[i * N_rowStride + j * N_colStride]; }
+
+    T_numtype operator()(int i, int j) const
+    { return data_[i * N_rowStride + j * N_colStride]; }
+
+protected:
+    T_numtype * restrict const data_;
+};
+
+template<typename P_numtype, int N_rows, int N_columns>
+class TinyMatrix {
+
+public:
+    typedef P_numtype T_numtype;
+    typedef _bz_tinyMatrixRef<T_numtype, N_rows, N_columns, N_columns, 1> 
+        T_reference;
+    typedef TinyMatrix<T_numtype, N_rows, N_columns> T_matrix;
+
+    TinyMatrix() { }
+
+    T_numtype* restrict data()
+    { return data_; }
+
+    const T_numtype* restrict data() const
+    { return data_; }
+
+    T_numtype* restrict dataFirst()
+    { return data_; }
+
+    const T_numtype* restrict dataFirst() const
+    { return data_; }
+
+    // NEEDS_WORK -- precondition checks
+    T_numtype& restrict operator()(int i, int j)
+    { return data_[i*N_columns + j]; }
+
+    T_numtype operator()(int i, int j) const
+    { return data_[i*N_columns + j]; }
+
+    T_reference getRef()
+    { return T_reference((T_numtype*)data_); }
+
+    const T_reference getRef() const
+    { return T_reference((T_numtype*)data_); }
+
+    // Scalar operand
+    ListInitializationSwitch<T_matrix,T_numtype*>
+    operator=(T_numtype x)
+    {
+        return ListInitializationSwitch<T_matrix,T_numtype*>(*this, x);
+    }
+
+    template<typename T_expr>
+    TinyMatrix<T_numtype, N_rows, N_columns>&
+    operator=(_bz_tinyMatExpr<T_expr> expr)
+    {
+        _bz_meta_matAssign<N_rows, N_columns, 0>::f(*this, expr,
+            _bz_update<T_numtype, _bz_typename T_expr::T_numtype>());
+        return *this;
+    }
+
+    void initialize(T_numtype x)
+    { 
+        for (int i=0; i < N_rows; ++i)
+          for (int j=0; j < N_columns; ++j)
+            (*this)(i,j) = x;
+    }
+
+    T_numtype* restrict getInitializationIterator()
+    { return dataFirst(); }
+
+protected:
+    T_numtype data_[N_rows * N_columns];
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/meta/matvec.h>     // Matrix-vector product metaprogram
+#include <blitz/meta/matmat.h>     // Matrix-matrix products
+#include <blitz/tinymatio.cc>      // I/O operations
+
+#endif // BZ_TINYMAT_H
+
Index: /XMLIO_V2/external/include/blitz/tinymatexpr.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tinymatexpr.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinymatexpr.h	(revision 73)
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/tinymatexpr.h   Tiny Matrix Expressions
+ *
+ * $Id: tinymatexpr.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TINYMATEXPR_H
+#define BZ_TINYMATEXPR_H
+
+#ifndef BZ_TINYMAT_H
+ #error <blitz/tinymatexpr.h> must be included via <blitz/tinymat.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename T_expr>
+class _bz_tinyMatExpr {
+public:
+    typedef _bz_typename T_expr::T_numtype T_numtype;
+
+    static const int
+        rows = T_expr::rows,
+        columns = T_expr::columns;
+
+    _bz_tinyMatExpr(T_expr expr)
+        : expr_(expr)
+    { }
+
+    _bz_tinyMatExpr(const _bz_tinyMatExpr<T_expr>& x)
+        : expr_(x.expr_)
+    { }
+
+    T_numtype operator()(int i, int j) const
+    { return expr_(i,j); }
+
+protected:
+    T_expr expr_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TINYMATEXPR_H
+
Index: /XMLIO_V2/external/include/blitz/tinymatio.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/tinymatio.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinymatio.cc	(revision 73)
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_TINYMATIO_CC
+#define BZ_TINYMATIO_CC
+
+#ifndef BZ_TINYMAT_H
+ #include <blitz/tinymat.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template <typename P_numtype, int N_rows, int N_columns>
+ostream& operator<<(ostream& os,
+    const TinyMatrix<P_numtype, N_rows, N_columns>& x)
+{
+    os << "(" << N_rows << "," << N_columns << "): " << endl;
+    for (int i=0; i < N_rows; ++i)
+    {
+        os << " [ ";
+        for (int j=0; j < N_columns; ++j)
+        {
+            os << setw(10) << x(i,j);
+            if (!((j+1)%7))
+                os << endl << "  ";
+        }
+        os << " ]" << endl;
+    }
+    return os;
+}
+
+template <typename P_numtype, int N_rows, int N_columns>
+istream& operator>>(istream& is, 
+    TinyMatrix<P_numtype, N_rows, N_columns>& x)
+{
+    int rows, columns;
+    char sep;
+             
+    is >> rows >> columns;
+
+    BZPRECHECK(rows == N_rows, "Size mismatch in number of rows");
+    BZPRECHECK(columns == N_columns, "Size mismatch in number of columns");
+
+    for (int i=0; i < N_rows; ++i) 
+    {
+        is >> sep;
+        BZPRECHECK(sep == '[', "Format error while scanning input matrix"
+            << endl << " (expected '[' before beginning of row data)");
+        for (int j = 0; j < N_columns; ++j)
+        {
+            BZPRECHECK(!is.bad(), "Premature end of input while scanning matrix");
+            is >> x(i,j);
+        }
+        is >> sep;
+        BZPRECHECK(sep == ']', "Format error while scanning input matrix"
+            << endl << " (expected ']' after end of row data)");
+    }
+
+    return is;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TINYMATIO_CC
+
Index: /XMLIO_V2/external/include/blitz/tinyvec-et.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tinyvec-et.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinyvec-et.h	(revision 73)
@@ -0,0 +1,33 @@
+/***************************************************************************
+ * blitz/tinyvec-et.h    Tinyvector + vector expression templates
+ *
+ * $Id: tinyvec-et.h,v 1.2 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2000 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TINYVEC_ET_H
+#define BZ_TINYVEC_ET_H
+
+#include <blitz/tinyvec.h>
+#include <blitz/vector-et.h>     // vector expressions
+
+#endif  // BZ_TINYVEC_ET_H
+
Index: /XMLIO_V2/external/include/blitz/tinyvec.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/tinyvec.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinyvec.cc	(revision 73)
@@ -0,0 +1,630 @@
+/***************************************************************************
+ * blitz/tinyvec.cc  Declaration of TinyVector methods
+ *
+ * $Id: tinyvec.cc,v 1.9 2005/10/17 21:43:45 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TINYVEC_CC
+#define BZ_TINYVEC_CC
+
+#include <blitz/tinyvec.h>
+#include <blitz/vector.h>
+#include <blitz/range.h>
+#include <blitz/meta/vecassign.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>::TinyVector(const T_numtype initValue) {
+    for (int i=0; i < N_length; ++i)
+        data_[i] = initValue;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>::TinyVector(const TinyVector<T_numtype, N_length>& x) {
+    for (int i=0; i < N_length; ++i)
+        data_[i] = x.data_[i];
+}
+
+template<typename P_numtype, int N_length>
+template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>::TinyVector(const TinyVector<P_numtype2, N_length>& x) {
+    for (int i=0; i < N_length; ++i)
+        data_[i] = static_cast<P_numtype>(x[i]);
+}
+
+template<typename P_numtype, int N_length>
+template<typename P_expr, typename P_updater>
+inline void TinyVector<P_numtype, N_length>::_bz_assign(P_expr expr, P_updater up) {
+    BZPRECHECK(expr.length(N_length) == N_length,
+        "An expression with length " << expr.length(N_length)
+        << " was assigned to a TinyVector<"
+        << BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_numtype)
+        << "," << N_length << ">");
+
+    if (expr._bz_hasFastAccess()) {
+        _bz_meta_vecAssign<N_length, 0>::fastAssign(*this, expr, up);
+    } else {
+        _bz_meta_vecAssign<N_length, 0>::assign(*this, expr, up);
+    }
+}
+
+// Constructor added by Peter Nordlund (peter.nordlund@ind.af.se)
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>::TinyVector(_bz_VecExpr<P_expr> expr) 
+{
+  _bz_assign(expr, _bz_update<T_numtype, _bz_typename P_expr::T_numtype>());
+}
+
+/*****************************************************************************
+ * Assignment operators with vector expression operand
+ */
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>& 
+TinyVector<P_numtype, N_length>::operator=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_update<T_numtype, _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_plus_update<T_numtype, 
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_minus_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_multiply_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_divide_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_mod_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_xor_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitand_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitor_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator<<=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftl_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_expr>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftr_update<T_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with scalar operand
+ */
+
+template<typename P_numtype, int N_length> 
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::initialize(const T_numtype x)
+{
+#ifndef BZ_KCC_COPY_PROPAGATION_KLUDGE
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(T_expr(x));
+#else
+    // Avoid using the copy propagation kludge for this simple
+    // operation.
+    for (int i=0; i < N_length; ++i)
+        data_[i] = x;
+#endif
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) += _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) -= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) *= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) /= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) %= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) ^= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) &= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(const T_numtype x)
+{
+    typedef _bz_VecExprConstant<T_numtype> T_expr;
+    (*this) |= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator<<=(const int x)
+{
+    typedef _bz_VecExprConstant<int> T_expr;
+    (*this) <<= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(const int x)
+{
+    typedef _bz_VecExprConstant<int> T_expr;
+    (*this) >>= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with TinyVector operand
+ */
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) = _bz_VecExpr<_bz_typename 
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) += _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) -= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) *= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) /= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) %= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) ^= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) &= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) |= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator<<=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) <<= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(const TinyVector<P_numtype2, N_length>& x) {
+    (*this) >>= _bz_VecExpr<_bz_typename
+        TinyVector<P_numtype2, N_length>::T_constIterator>(x.beginFast());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Vector operand
+ */
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator=(const Vector<P_numtype2>& x) {
+    (*this) = x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(const Vector<P_numtype2>& x) {
+    (*this) += x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(const Vector<P_numtype2>& x) {
+    (*this) -= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(const Vector<P_numtype2>& x) {
+    (*this) *= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(const Vector<P_numtype2>& x) {
+    (*this) /= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(const Vector<P_numtype2>& x) {
+    (*this) %= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(const Vector<P_numtype2>& x) {
+    (*this) ^= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(const Vector<P_numtype2>& x) {
+    (*this) &= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(const Vector<P_numtype2>& x) {
+    (*this) |= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator<<=(const Vector<P_numtype2>& x) {
+    (*this) <<= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(const Vector<P_numtype2>& x) {
+    (*this) >>= x._bz_asVecExpr();
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Range operand
+ */
+
+template<typename P_numtype, int N_length> 
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator=(const Range& r) {
+    (*this) = r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(const Range& r) {
+    (*this) += r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(const Range& r) {
+    (*this) -= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(const Range& r) {
+    (*this) *= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(const Range& r) {
+    (*this) /= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(const Range& r) {
+    (*this) %= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(const Range& r) {
+    (*this) ^= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(const Range& r) {
+    (*this) &= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(const Range& r) {
+    (*this) |= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator<<=(const Range& r) {
+    (*this) <<= r._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(const Range& r) {
+    (*this) >>= r._bz_asVecExpr();
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with VectorPick operand
+ */
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator=(const VectorPick<P_numtype2>& x)
+{
+    (*this) = x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator+=(const VectorPick<P_numtype2>& x)
+{
+    (*this) += x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator-=(const VectorPick<P_numtype2>& x)
+{
+    (*this) -= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator*=(const VectorPick<P_numtype2>& x)
+{
+    (*this) *= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator/=(const VectorPick<P_numtype2>& x)
+{
+    (*this) /= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator%=(const VectorPick<P_numtype2>& x)
+{
+    (*this) %= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator^=(const VectorPick<P_numtype2>& x)
+{
+    (*this) ^= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator&=(const VectorPick<P_numtype2>& x)
+{
+    (*this) &= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator|=(const VectorPick<P_numtype2>& x)
+{
+    (*this) |= x._bz_asVecExpr();
+    return *this;
+}
+
+template<typename P_numtype, int N_length> template<typename P_numtype2>
+inline TinyVector<P_numtype, N_length>&
+TinyVector<P_numtype, N_length>::operator>>=(const VectorPick<P_numtype2>& x)
+{
+    (*this) <<= x._bz_asVecExpr();
+    return *this;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TINYVEC_CC
Index: /XMLIO_V2/external/include/blitz/tinyvec.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tinyvec.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinyvec.h	(revision 73)
@@ -0,0 +1,435 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/tinyvec.h      Declaration of the TinyVector<T, N> class
+ *
+ * $Id: tinyvec.h,v 1.9 2005/10/06 23:23:40 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TINYVEC_H
+#define BZ_TINYVEC_H
+
+#include <blitz/blitz.h>
+#include <blitz/range.h>
+#include <blitz/listinit.h>
+#include <blitz/tiny.h>
+
+BZ_NAMESPACE(blitz)
+
+/*****************************************************************************
+ * Forward declarations
+ */
+
+template<typename P_numtype, int N_length, int N_stride BZ_TEMPLATE_DEFAULT(1) >
+class TinyVectorIter;
+
+template<typename P_numtype, int N_length, int N_stride BZ_TEMPLATE_DEFAULT(1) >
+class TinyVectorIterConst;
+
+template<typename P_numtype>
+class Vector;
+
+template<typename P_expr>
+class _bz_VecExpr;
+
+template<typename P_distribution>
+class Random;
+
+template<typename P_numtype>
+class VectorPick;
+
+template<typename T_numtype1, typename T_numtype2, int N_rows, int N_columns,
+    int N_vecStride>
+class _bz_matrixVectorProduct;
+
+
+
+/*****************************************************************************
+ * Declaration of class TinyVector
+ */
+
+template<typename P_numtype, int N_length>
+class TinyVector {
+public:
+
+    //////////////////////////////////////////////
+    // Public Types
+    //////////////////////////////////////////////
+
+    typedef P_numtype                                    T_numtype;
+    typedef TinyVector<T_numtype,N_length>               T_vector;
+    typedef TinyVectorIter<T_numtype,N_length,1>         T_iterator;
+    typedef TinyVectorIterConst<T_numtype,N_length,1>    T_constIterator;
+    typedef T_numtype*                                   iterator;
+    typedef const T_numtype*                             const_iterator;
+    enum { numElements = N_length };
+
+    TinyVector()  { }
+    ~TinyVector() { }
+
+    inline TinyVector(const TinyVector<T_numtype,N_length>& x);
+
+    template <typename T_numtype2>
+    inline TinyVector(const TinyVector<T_numtype2,N_length>& x);
+
+    inline TinyVector(const T_numtype initValue);
+
+    inline TinyVector(const T_numtype x[]) {
+        memcpy(data_,x,N_length*sizeof(T_numtype));
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+        data_[6] = x6;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
+        T_numtype x7)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+        data_[6] = x6;
+        data_[7] = x7;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
+        T_numtype x7, T_numtype x8)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+        data_[6] = x6;
+        data_[7] = x7;
+        data_[8] = x8;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
+        T_numtype x7, T_numtype x8, T_numtype x9)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+        data_[6] = x6;
+        data_[7] = x7;
+        data_[8] = x8;
+        data_[9] = x9;
+    }
+
+    TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
+        T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
+        T_numtype x7, T_numtype x8, T_numtype x9, T_numtype x10)
+    {
+        data_[0] = x0;
+        data_[1] = x1;
+        data_[2] = x2;
+        data_[3] = x3;
+        data_[4] = x4;
+        data_[5] = x5;
+        data_[6] = x6;
+        data_[7] = x7;
+        data_[8] = x8;
+        data_[9] = x9;
+        data_[10] = x10;
+    }
+
+    // Constructor added by Peter Nordlund
+    template<typename P_expr>
+    inline TinyVector(_bz_VecExpr<P_expr> expr);
+
+    T_iterator      beginFast()       { return T_iterator(*this);      }
+    T_constIterator beginFast() const { return T_constIterator(*this); }
+
+    iterator       begin()       { return data_; }
+    const_iterator begin() const { return data_; }
+
+    iterator       end()       { return data_ + N_length; }
+    const_iterator end() const { return data_ + N_length; }
+
+    T_numtype * restrict data()
+    { return data_; }
+
+    const T_numtype * restrict data() const
+    { return data_; }
+
+    T_numtype * restrict dataFirst()
+    { return data_; }
+
+    const T_numtype * restrict dataFirst() const
+    { return data_; }
+
+    unsigned length() const
+    { return N_length; }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    unsigned _bz_suggestLength() const
+    { return N_length; }
+
+    bool _bz_hasFastAccess() const
+    { return true; }
+
+    T_numtype& restrict _bz_fastAccess(unsigned i)
+    { return data_[i]; }
+
+    T_numtype _bz_fastAccess(unsigned i) const
+    { return data_[i]; }
+
+    template<typename P_expr, typename P_updater>
+    void _bz_assign(P_expr, P_updater);
+
+    _bz_VecExpr<T_constIterator> _bz_asVecExpr() const
+    { return _bz_VecExpr<T_constIterator>(beginFast()); }
+   
+    //////////////////////////////////////////////
+    // Subscripting operators
+    //////////////////////////////////////////////
+
+    bool lengthCheck(unsigned i) const
+    {
+        BZPRECHECK(i < N_length, 
+            "TinyVector<" << BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_numtype) 
+            << "," << N_length << "> index out of bounds: " << i);
+        return true;
+    }
+
+    const T_numtype& operator()(unsigned i) const
+    {
+        BZPRECONDITION(lengthCheck(i));
+        return data_[i];
+    }
+
+    T_numtype& restrict operator()(unsigned i)
+    { 
+        BZPRECONDITION(lengthCheck(i));
+        return data_[i];
+    }
+
+    const T_numtype& operator[](unsigned i) const
+    {
+        BZPRECONDITION(lengthCheck(i));
+        return data_[i];
+    }
+
+    T_numtype& restrict operator[](unsigned i)
+    {
+        BZPRECONDITION(lengthCheck(i));
+        return data_[i];
+    }
+
+    //////////////////////////////////////////////
+    // Assignment operators
+    //////////////////////////////////////////////
+
+    // Scalar operand
+    ListInitializationSwitch<T_vector,T_numtype*> operator=(T_numtype x)
+    {
+        return ListInitializationSwitch<T_vector,T_numtype*>(*this, x);
+    }
+
+    T_vector& initialize(const T_numtype);
+    T_vector& operator+=(const T_numtype);
+    T_vector& operator-=(const T_numtype);
+    T_vector& operator*=(const T_numtype);
+    T_vector& operator/=(const T_numtype);
+    T_vector& operator%=(const T_numtype);
+    T_vector& operator^=(const T_numtype);
+    T_vector& operator&=(const T_numtype);
+    T_vector& operator|=(const T_numtype);
+    T_vector& operator>>=(const int);
+    T_vector& operator<<=(const int);
+
+    template<typename P_numtype2> 
+    T_vector& operator=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator+=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator-=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator*=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator/=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator%=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator^=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator&=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator|=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator>>=(const TinyVector<P_numtype2, N_length> &);
+    template<typename P_numtype2>
+    T_vector& operator<<=(const TinyVector<P_numtype2, N_length> &);
+
+    template<typename P_numtype2> T_vector& operator=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator+=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator-=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator*=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator/=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator%=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator^=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator&=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator|=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator>>=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator<<=(const Vector<P_numtype2> &);
+
+    // Vector expression operand
+    template<typename P_expr> T_vector& operator=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator+=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator-=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator*=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator/=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator%=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator^=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator&=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator|=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator>>=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator<<=(_bz_VecExpr<P_expr>);
+
+    // VectorPick operand
+    template<typename P_numtype2>
+    T_vector& operator=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator+=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator-=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator*=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator/=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator%=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator^=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator&=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator|=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator>>=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator<<=(const VectorPick<P_numtype2> &);
+
+    // Range operand
+    T_vector& operator=(const Range&);
+    T_vector& operator+=(const Range&);
+    T_vector& operator-=(const Range&);
+    T_vector& operator*=(const Range&);
+    T_vector& operator/=(const Range&);
+    T_vector& operator%=(const Range&);
+    T_vector& operator^=(const Range&);
+    T_vector& operator&=(const Range&);
+    T_vector& operator|=(const Range&);
+    T_vector& operator>>=(const Range&);
+    T_vector& operator<<=(const Range&);
+
+    T_numtype* restrict getInitializationIterator()
+    { return dataFirst(); }
+
+private:
+    T_numtype data_[N_length];
+};
+
+
+// Specialization for N = 0: KCC is giving some
+// peculiar errors, perhaps this will fix.
+
+template<typename T>
+class TinyVector<T,0> {
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/tinyveciter.h>  // Iterators
+#include <blitz/tvecglobs.h>    // Global functions
+#include <blitz/vector.h>       // Expression templates
+#include <blitz/tinyvec.cc>     // Member functions
+#include <blitz/tinyvecio.cc>   // I/O functions
+
+#endif // BZ_TINYVEC_H
+
Index: /XMLIO_V2/external/include/blitz/tinyvecio.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/tinyvecio.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinyvecio.cc	(revision 73)
@@ -0,0 +1,62 @@
+/*
+ * $Id: tinyvecio.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_TINYVECIO_CC
+#define BZ_TINYVECIO_CC
+
+#ifndef BZ_TINYVEC_H
+ #include <blitz/tinyvec.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// NEEDS_WORK
+
+template<typename P_numtype, int N_length>
+ostream& operator<<(ostream& os, const TinyVector<P_numtype, N_length>& x)
+{
+    os << N_length << " [ ";
+    for (int i=0; i < N_length; ++i)
+    {
+        os << setw(10) << x[i];
+        if (!((i+1)%7))
+            os << endl << "  ";
+    }
+    os << " ]";
+    return os;
+}
+
+// Input of tinyvec contribute by Adam Levar <adaml@mcneilhouse.com>
+template <typename T_numtype, int N_length>
+istream& operator>>(istream& is, TinyVector<T_numtype, N_length>& x)
+{
+    int length;
+    char sep;
+             
+    is >> length;
+    is >> sep;
+    BZPRECHECK(sep == '[', "Format error while scanning input array"
+        << endl << " (expected '[' before beginning of array data)");
+
+    BZPRECHECK(length == N_length, "Size mismatch");                    
+    for (int i = 0; i < N_length; ++i)
+    {
+        BZPRECHECK(!is.bad(), "Premature end of input while scanning array");
+        is >> x(i);
+    }
+    is >> sep;
+    BZPRECHECK(sep == ']', "Format error while scanning input array"
+       << endl << " (expected ']' after end of array data)");
+    
+    return is;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TINYVECIO_CC
Index: /XMLIO_V2/external/include/blitz/tinyveciter.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tinyveciter.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tinyveciter.h	(revision 73)
@@ -0,0 +1,163 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/tinyveciter.h   Declaration of TinyVectorIter<T,N,stride>
+ *
+ * $Id: tinyveciter.h,v 1.6 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_TINYVECITER_H
+#define BZ_TINYVECITER_H
+
+#ifndef BZ_TINYVEC_H
+ #include <blitz/tinyvec.h>
+#endif
+
+#ifndef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+ #error "Debug in tinyveciter.h (this line shouldn't be here)"
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// N_stride has default 1, in forward declaration in <blitz/tinyvec.h>
+template<typename P_numtype, int N_length, int N_stride>
+class TinyVectorIter {
+public:
+    typedef P_numtype T_numtype;
+
+    explicit TinyVectorIter(TinyVector<T_numtype, N_length>& x)
+        : data_(x.data())
+    { }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    TinyVectorIter(const TinyVectorIter<T_numtype, N_length, N_stride>& iter)
+        : data_(iter.data_)
+    {
+    }
+#endif
+
+    T_numtype operator[](int i) const
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    T_numtype& restrict operator[](int i)
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    T_numtype operator()(int i) const
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    T_numtype& restrict operator()(int i)
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    int length(int) const
+    { return N_length; }
+
+    static const int _bz_staticLengthCount = 1,
+                     _bz_dynamicLengthCount = 0,
+                     _bz_staticLength = 0;
+
+    bool _bz_hasFastAccess() const
+    { return true; }
+
+    T_numtype _bz_fastAccess(int i) const
+    { return data_[i * N_stride]; }
+
+    T_numtype& _bz_fastAccess(int i)
+    { return data_[i * N_stride]; }
+
+    int _bz_suggestLength() const
+    { return N_length; }
+
+private:
+    T_numtype * restrict data_;
+};
+
+// N_stride has default 1, in forward declaration in <blitz/tinyvec.h>
+template<typename P_numtype, int N_length, int N_stride>
+class TinyVectorIterConst {
+public:
+    typedef P_numtype T_numtype;
+
+    explicit TinyVectorIterConst(const TinyVector<T_numtype, N_length>& x)
+        : data_(x.data())
+    { }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    TinyVectorIterConst(const TinyVectorIterConst<T_numtype, N_length, 
+        N_stride>& iter)
+        : data_(iter.data_)
+    {
+    }
+
+    void operator=(const TinyVectorIterConst<T_numtype, N_length, N_stride>& 
+        iter)
+    {
+        data_ = iter.data_;
+    }
+#endif
+
+    T_numtype operator[](int i) const
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    T_numtype operator()(int i) const
+    {
+        BZPRECONDITION(i >= 0 && i < N_length);
+        return data_[i * N_stride];
+    }
+
+    int length(int) const
+    { return N_length; }
+
+    static const int _bz_staticLengthCount = 1,
+                     _bz_dynamicLengthCount = 0,
+                     _bz_staticLength = 0;
+
+    bool _bz_hasFastAccess() const
+    { return true; }
+
+    T_numtype _bz_fastAccess(int i) const
+    { return data_[i * N_stride]; }
+
+    int _bz_suggestLength() const
+    { return N_length; }
+
+private:
+    const T_numtype * restrict data_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TINYVECITER_H
Index: /XMLIO_V2/external/include/blitz/traversal.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/traversal.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/traversal.cc	(revision 73)
@@ -0,0 +1,129 @@
+/***************************************************************************
+ * blitz/traversal.cc  Space-filling curve based traversal orders
+ *
+ * $Id: traversal.cc,v 1.4 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TRAVERSAL_CC
+#define BZ_TRAVERSAL_CC
+
+#ifndef BZ_TRAVERSAL_H
+ #error <blitz/traversal.cc> must be included via <blitz/traversal.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Next line is a workaround for Intel C++ V4.0 oddity, due
+// to Allan Stokes.
+static set<TraversalOrder<2> > *_bz_intel_kludge;
+
+//template<int N_dimensions>
+//_bz_typename TraversalOrderCollection<N_dimensions>::T_set
+//    TraversalOrderCollection<N_dimensions>::traversals_;
+
+template<int N>
+void makeHilbert(Vector<TinyVector<int,N> >& coord, 
+    int x0, int y0, int xis, int xjs,
+    int yis, int yjs, int n, int& i)
+{
+    // N != 2 is not yet implemented.
+    BZPRECONDITION(N == 2);
+
+    if (!n)
+    {
+        if (i > coord.length())
+        {
+            cerr << "makeHilbert: vector not long enough" << endl;
+            exit(1);
+        }
+        coord[i][0] = x0 + (xis+yis)/2;
+        coord[i][1] = y0 + (xjs+yjs)/2;
+        ++i;
+    }
+    else {
+        makeHilbert(coord,x0,y0,yis/2, yjs/2, xis/2, xjs/2, n-1, i);
+        makeHilbert(coord,x0+xis/2,y0+xjs/2,xis/2,xjs/2,yis/2,yjs/2,n-1,i);
+        makeHilbert(coord,x0+xis/2+yis/2,y0+xjs/2+yjs/2,xis/2,xjs/2,yis/2,
+            yjs/2,n-1,i);
+        makeHilbert(coord,x0+xis/2+yis, y0+xjs/2+yjs, -yis/2,-yjs/2,-xis/2,
+            -xjs/2,n-1,i);
+    }
+}
+
+template<int N_dimensions>
+void MakeHilbertTraversal(Vector<TinyVector<int,N_dimensions> >& coord, 
+    int length)
+{
+    // N_dimensions != 2 not yet implemented
+    BZPRECONDITION(N_dimensions == 2);
+
+    // The constant on the next line is ln(2)
+    int d = (int)(::ceil(::log((double)length) / 0.693147180559945309417));  
+
+    int N = 1 << d;
+    const int Npoints = N*N;
+    Vector<TinyVector<int,2> > coord2(Npoints);
+
+    int i=0;
+    makeHilbert(coord2,0,0,32768,0,0,32768,d,i);
+
+    int xp0 = coord2[0][0];
+    int yp0 = coord2[0][1];
+
+    int j=0;
+
+    coord.resize(length * length);
+
+    for (int i=0; i < Npoints; ++i)
+    {
+        coord2[i][0] = (coord2[i][0]-xp0)/(2*xp0);
+        coord2[i][1] = (coord2[i][1]-yp0)/(2*yp0);
+
+        if ((coord2[i][0] < length) && (coord2[i][1] < length) 
+            && (coord2[i][0] >= 0) && (coord2[i][1] >= 0))
+        {
+            coord[j][0] = coord2[i][0];
+            coord[j][1] = coord2[i][1];
+            ++j;
+        }
+    }
+}
+
+template<int N_dimensions>
+void generateFastTraversalOrder(const TinyVector<int,N_dimensions>& size)
+{
+    BZPRECONDITION(N_dimensions == 2);
+    BZPRECONDITION(size[0] == size[1]);
+
+    TraversalOrderCollection<2> travCol;
+    if (travCol.find(size))
+        return;
+
+    Vector<TinyVector<int,2> > ordering(size[0]);
+
+    MakeHilbertTraversal(ordering, size[0]);
+    travCol.insert(TraversalOrder<2>(size, ordering));
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TRAVERSAL_CC
Index: /XMLIO_V2/external/include/blitz/traversal.h
===================================================================
--- /XMLIO_V2/external/include/blitz/traversal.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/traversal.h	(revision 73)
@@ -0,0 +1,165 @@
+/***************************************************************************
+ * blitz/traversal.h      Declaration of the TraversalOrder classes
+ *
+ * $Id: traversal.h,v 1.5 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+// Fast traversal orders require the ISO/ANSI C++ standard library
+// (particularly set).
+#ifdef BZ_HAVE_STD
+
+#ifndef BZ_TRAVERSAL_H
+#define BZ_TRAVERSAL_H
+
+#ifndef BZ_TINYVEC_H
+ #include <blitz/tinyvec.h>
+#endif
+
+#ifndef BZ_VECTOR_H
+ #include <blitz/vector.h>
+#endif
+
+#include <set>
+
+BZ_NAMESPACE(blitz)
+
+template<int N_dimensions>
+class TraversalOrder {
+
+public:
+    typedef TinyVector<int, N_dimensions> T_coord;
+    typedef Vector<T_coord>               T_traversal;
+
+    TraversalOrder()
+    {
+        size_ = 0;
+    }
+
+    TraversalOrder(const T_coord& size, T_traversal& order)
+        : size_(size), order_(order)
+    { }
+
+    TraversalOrder(const T_coord& size)
+        : size_(size)
+    { }
+
+    T_coord operator[](int i) const
+    { return order_[i]; }
+
+    T_coord& operator[](int i)
+    { return order_[i]; }
+
+    int length() const
+    { return order_.length(); }
+
+    bool operator<(const TraversalOrder<N_dimensions>& x) const
+    {
+        for (int i=0; i < N_dimensions; ++i)
+        {
+            if (size_[i] < x.size_[i])
+                return true;
+            else if (size_[i] > x.size_[i])
+                return false;
+        }
+        return false;
+    }
+
+    bool operator==(const TraversalOrder<N_dimensions>& x) const
+    {
+        for (int i=0; i < N_dimensions; ++i)
+        {
+            if (size_[i] != x.size_[i])
+                return false;
+        }
+
+        return true;
+    }
+
+protected:
+    T_traversal order_;
+    T_coord     size_;
+};
+
+/*
+ * This specialization is provided to avoid problems with zero-length
+ * vectors.
+ */
+template<>
+class TraversalOrder<0> {
+public:
+     TraversalOrder () {} // AJS
+};
+
+template<int N_dimensions>
+class TraversalOrderCollection {
+public:
+    typedef TraversalOrder<N_dimensions>        T_traversal;
+    typedef _bz_typename T_traversal::T_coord   T_coord;
+    typedef set<T_traversal>                    T_set;
+    typedef _bz_typename set<T_traversal>::const_iterator T_iterator;
+
+    const T_traversal* find(const T_coord& size)
+    {
+        T_iterator iter = traversals_.find(T_traversal(size));
+        if (iter != traversals_.end())
+            return &(*iter);
+        return 0;
+    }
+
+    void insert(T_traversal x)
+    {
+        traversals_.insert(x);
+    }
+
+protected:
+    static T_set traversals_;
+};
+
+template<int N_dimensions>
+_bz_typename TraversalOrderCollection<N_dimensions>::T_set
+    TraversalOrderCollection<N_dimensions>::traversals_;
+
+/*
+ * This specialization is provided to avoid problems with zero-length
+ * vectors.
+ */
+
+template<>
+class TraversalOrderCollection<0> {
+public:
+    typedef int T_traversal;
+    typedef int T_coord;
+    typedef int T_set;
+    typedef int T_iterator;
+
+    const T_traversal* find(const T_coord& size)
+    { return 0; }
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/traversal.cc>
+
+#endif // BZ_TRAVERSAL_H
+
+#endif // BZ_HAVE_STD
+
Index: /XMLIO_V2/external/include/blitz/tuning.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tuning.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tuning.h	(revision 73)
@@ -0,0 +1,143 @@
+/***************************************************************************
+ * blitz/tuning.h      Platform-specific code tuning
+ *
+ * $Id: tuning.h,v 1.4 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TUNING_H
+#define BZ_TUNING_H
+
+// These estimates should be conservative (i.e. underestimate the
+// cache sizes).
+#define BZ_L1_CACHE_ESTIMATED_SIZE    8192
+#define BZ_L2_CACHE_ESTIMATED_SIZE    65536
+
+
+#undef  BZ_PARTIAL_LOOP_UNROLL
+#define BZ_PASS_EXPR_BY_VALUE
+#undef  BZ_PTR_INC_FASTER_THAN_INDIRECTION
+#define BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+#undef  BZ_KCC_COPY_PROPAGATION_KLUDGE
+#undef  BZ_ALTERNATE_FORWARD_BACKWARD_TRAVERSALS
+#undef  BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE
+#define BZ_INLINE_GROUP1
+#define BZ_INLINE_GROUP2
+#define BZ_COLLAPSE_LOOPS
+#define BZ_USE_FAST_READ_ARRAY_EXPR
+#define BZ_ARRAY_EXPR_USE_COMMON_STRIDE
+#undef  BZ_ARRAY_SPACE_FILLING_TRAVERSAL
+#undef  BZ_ARRAY_FAST_TRAVERSAL_UNROLL
+#undef  BZ_ARRAY_STACK_TRAVERSAL_CSE_AND_ANTIALIAS
+#undef  BZ_ARRAY_STACK_TRAVERSAL_UNROLL
+#define BZ_ARRAY_2D_STENCIL_TILING
+#define BZ_ARRAY_2D_STENCIL_TILE_SIZE       128
+#undef  BZ_INTERLACE_ARRAYS
+#undef  BZ_ALIGN_BLOCKS_ON_CACHELINE_BOUNDARY
+#define BZ_FAST_COMPILE
+
+
+#ifndef BZ_DISABLE_NEW_ET
+ #define BZ_NEW_EXPRESSION_TEMPLATES
+#endif
+
+#ifdef BZ_FAST_COMPILE
+#define BZ_ETPARMS_CONSTREF
+#define BZ_NO_INLINE_ET
+#endif
+
+/*
+ * Platform-specific tuning
+ */
+
+#ifdef _CRAYT3E
+ // The backend compiler on the T3E does a better job of
+ // loop unrolling.
+ #undef BZ_PARTIAL_LOOP_UNROLL
+ #undef BZ_ARRAY_FAST_TRAVERSAL_UNROLL
+ #undef BZ_ARRAY_STACK_TRAVERSAL_UNROLL
+#endif
+
+#ifdef __GNUC__
+ // The egcs compiler does a good job of loop unrolling, if
+ // -funroll-loops is used.
+ #undef BZ_PARTIAL_LOOP_UNROLL
+ #undef BZ_ARRAY_FAST_TRAVERSAL_UNROLL
+ #undef BZ_ARRAY_STACK_TRAVERSAL_UNROLL
+#endif
+
+#ifdef  BZ_DISABLE_KCC_COPY_PROPAGATION_KLUDGE
+ #undef BZ_KCC_COPY_PROPAGATION_KLUDGE
+#endif
+
+#ifdef  BZ_INLINE_GROUP1
+ #define _bz_inline1 inline
+#else
+ #define _bz_inline1
+#endif
+
+#ifdef  BZ_INLINE_GROUP2
+ #define _bz_inline2 inline
+#else
+ #define _bz_inline2
+#endif
+
+#ifdef  BZ_NO_INLINE_ET
+ #define _bz_inline_et 
+#else
+ #define _bz_inline_et inline
+#endif
+
+#ifdef  BZ_ETPARMS_CONSTREF
+ #define BZ_ETPARM(X) const X&
+#else
+ #define BZ_ETPARM(X) X
+#endif
+
+#ifdef __DECCXX
+ // The DEC cxx compiler has problems with loop unrolling
+ // because of aliasing.  Loop unrolling and anti-aliasing
+ // is done by Blitz++.
+
+  #define  BZ_PARTIAL_LOOP_UNROLL
+  #define  BZ_ARRAY_STACK_TRAVERSAL_CSE_AND_ANTIALIAS
+  #define  BZ_ARRAY_STACK_TRAVERSAL_UNROLL
+#endif
+
+/*
+ * BZ_NO_PROPAGATE(X) prevents the compiler from performing
+ * copy propagation on a variable.  This is used for loop
+ * unrolling to prevent KAI C++ from rearranging the
+ * ordering of memory accesses.
+ */
+
+#define BZ_NO_PROPAGATE(X)   X
+
+#ifdef __KCC
+#ifdef BZ_USE_NO_PROPAGATE
+    extern "C" int __kai_apply(const char*, ...);
+
+    #undef  BZ_NO_PROPAGATE(X)
+    #define BZ_NO_PROPAGATE(X)  __kai_apply("(%a)",&X)
+#endif
+#endif
+
+#endif // BZ_TUNING_H
Index: /XMLIO_V2/external/include/blitz/tvcross.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tvcross.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tvcross.h	(revision 73)
@@ -0,0 +1,53 @@
+/***************************************************************************
+ * blitz/tvcross.h      Cross product of TinyVector<N,3>'s
+ *
+ * $Id: tvcross.h,v 1.4 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TVCROSS_H
+#define BZ_TVCROSS_H
+
+#ifndef BZ_TINYVEC_H
+ #error <blitz/tvcross.h> must be included via <blitz/tinyvec.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+/*
+ * cross product.
+ *
+ * NEEDS_WORK: - cross product of two different vector types
+ *             - cross product involving expressions
+ */
+
+template<typename T_numtype>
+TinyVector<T_numtype,3> cross(const TinyVector<T_numtype,3>& x, 
+    const TinyVector<T_numtype,3>& y)
+{
+    return TinyVector<T_numtype,3>(x[1]*y[2] - y[1]*x[2],
+        y[0]*x[2] - x[0]*y[2], x[0]*y[1] - y[0]*x[1]);
+}
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TVCROSS_H
Index: /XMLIO_V2/external/include/blitz/tvecglobs.h
===================================================================
--- /XMLIO_V2/external/include/blitz/tvecglobs.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/tvecglobs.h	(revision 73)
@@ -0,0 +1,81 @@
+/***************************************************************************
+ * blitz/tvecglobs.h     TinyVector global functions
+ *
+ * $Id: tvecglobs.h,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_TVECGLOBS_H
+#define BZ_TVECGLOBS_H
+
+#ifndef BZ_META_METAPROG_H
+ #include <blitz/meta/metaprog.h>
+#endif
+
+#ifndef BZ_NUMTRAIT_H
+ #include <blitz/numtrait.h>
+#endif
+
+#include <blitz/tvcross.h>       // Cross products
+#include <blitz/meta/dot.h>
+#include <blitz/meta/product.h>
+#include <blitz/meta/sum.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename T_numtype1, typename T_numtype2, int N_length>
+inline BZ_PROMOTE(T_numtype1, T_numtype2)
+dot(const TinyVector<T_numtype1, N_length>& a, 
+    const TinyVector<T_numtype2, N_length>& b)
+{
+    return _bz_meta_vectorDot<N_length, 0>::f(a,b);
+}
+
+template<typename T_expr1, typename T_numtype2, int N_length>
+inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, T_numtype2)
+dot(_bz_VecExpr<T_expr1> a, const TinyVector<T_numtype2, N_length>& b)
+{
+    return _bz_meta_vectorDot<N_length, 0>::f_value_ref(a,b);
+}
+
+template<typename T_numtype1, typename T_expr2, int N_length>
+inline BZ_PROMOTE(T_numtype1, _bz_typename T_expr2::T_numtype)
+dot(const TinyVector<T_numtype1, N_length>& a, _bz_VecExpr<T_expr2> b)
+{
+    return _bz_meta_vectorDot<N_length, 0>::f_ref_value(a,b);
+}
+
+template<typename T_numtype1, int N_length>
+inline BZ_SUMTYPE(T_numtype1)
+product(const TinyVector<T_numtype1, N_length>& a)
+{
+    return _bz_meta_vectorProduct<N_length, 0>::f(a);
+}
+
+template<typename T_numtype, int N_length>
+inline T_numtype
+sum(const TinyVector<T_numtype, N_length>& a)
+{
+    return _bz_meta_vectorSum<N_length, 0>::f(a);
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_TVECGLOBS_H
+
Index: /XMLIO_V2/external/include/blitz/update.h
===================================================================
--- /XMLIO_V2/external/include/blitz/update.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/update.h	(revision 73)
@@ -0,0 +1,70 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/update.h      Declaration of the _bz_XXXX updater classes
+ *
+ * $Id: update.h,v 1.5 2004/03/09 21:55:31 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_UPDATE_H
+#define BZ_UPDATE_H
+
+#include <blitz/blitz.h>
+
+BZ_NAMESPACE(blitz)
+
+class _bz_updater_base { };
+
+#define BZ_DECL_UPDATER(name,op,symbol)                     \
+  template<typename X, typename Y>                          \
+  class name : public _bz_updater_base {                    \
+  public:                                                   \
+    static inline void update(X& restrict x, Y y)           \
+    { x op y; }                                             \
+    static void prettyPrint(BZ_STD_SCOPE(string) &str)      \
+    { str += symbol; }                                      \
+  }
+
+template<typename X, typename Y>
+class _bz_update : public _bz_updater_base {
+  public:
+    static inline void update(X& restrict x, Y y)
+    { x = (X)y; }
+
+    static void prettyPrint(BZ_STD_SCOPE(string) &str)
+    { str += "="; }
+};
+
+BZ_DECL_UPDATER(_bz_plus_update, +=, "+=");
+BZ_DECL_UPDATER(_bz_minus_update, -=, "-=");
+BZ_DECL_UPDATER(_bz_multiply_update, *=, "*=");
+BZ_DECL_UPDATER(_bz_divide_update, /=, "/=");
+BZ_DECL_UPDATER(_bz_mod_update, %=, "%=");
+BZ_DECL_UPDATER(_bz_xor_update, ^=, "^=");
+BZ_DECL_UPDATER(_bz_bitand_update, &=, "&=");
+BZ_DECL_UPDATER(_bz_bitor_update, |=, "|=");
+BZ_DECL_UPDATER(_bz_shiftl_update, <<=, "<<=");
+BZ_DECL_UPDATER(_bz_shiftr_update, >>=, ">>=");
+
+BZ_NAMESPACE_END
+
+#endif // BZ_UPDATE_H
+
Index: /XMLIO_V2/external/include/blitz/vecaccum.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecaccum.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecaccum.cc	(revision 73)
@@ -0,0 +1,68 @@
+/*
+ * $Id: vecaccum.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECACCUM_CC
+#define BZ_VECACCUM_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecaccum.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P>
+inline
+Vector<BZ_SUMTYPE(_bz_typename P::T_numtype)> _bz_vec_accumulate(P expr)
+{
+    typedef BZ_SUMTYPE(_bz_typename P::T_numtype) T_sumtype;
+    int length = expr._bz_suggestLength();
+    Vector<T_sumtype> z(length);
+    T_sumtype sum = 0;
+
+    if (expr._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+        {
+            sum += expr._bz_fastAccess(i);
+            z[i] = sum;
+        }
+    }
+    else {
+        for (int i=0; i < length; ++i)
+        {
+            sum += expr(i);
+            z[i] = sum;
+        }
+    }
+
+    return z;
+}
+template<typename P_numtype>
+Vector<BZ_SUMTYPE(P_numtype)> accumulate(const Vector<P_numtype>& x)
+{
+    return _bz_vec_accumulate(x);
+}
+
+template<typename P_expr>
+Vector<BZ_SUMTYPE(_bz_typename P_expr::T_numtype)>
+accumulate(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_accumulate(x);
+}
+
+template<typename P_numtype>
+Vector<BZ_SUMTYPE(P_numtype)> accumulate(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_accumulate(x);
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECACCUM_CC
+
Index: /XMLIO_V2/external/include/blitz/vecall.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecall.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecall.cc	(revision 73)
@@ -0,0 +1,66 @@
+/*
+ * $Id: vecall.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECALL_CC
+#define BZ_VECALL_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecall.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline bool _bz_vec_all(P_expr vector)
+{
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            if (!vector._bz_fastAccess(i))
+                return false;
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            if (!vector[i])
+                return false;
+    }
+
+    return true;
+}
+
+template<typename P_numtype>
+inline bool all(const Vector<P_numtype>& x)
+{
+    return _bz_vec_all(x._bz_asVecExpr());
+}
+
+template<typename P_expr>
+inline bool all(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_all(expr);
+}
+
+template<typename P_numtype>
+inline bool all(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_all(x._bz_asVecExpr());
+}
+
+template<typename P_numtype, int N_dimensions>
+inline bool all(const TinyVector<P_numtype, N_dimensions>& x)
+{
+    return _bz_vec_all(x._bz_asVecExpr());
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECALL_CC
+
Index: /XMLIO_V2/external/include/blitz/vecany.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecany.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecany.cc	(revision 73)
@@ -0,0 +1,66 @@
+/*
+ * $Id: vecany.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECANY_CC
+#define BZ_VECANY_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecany.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline bool _bz_vec_any(P_expr vector)
+{
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            if (vector._bz_fastAccess(i))
+                return true;
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            if (vector[i])
+                return true;
+    }
+
+    return false;
+}
+
+template<typename P_numtype>
+inline bool any(const Vector<P_numtype>& x)
+{
+    return _bz_vec_any(x._bz_asVecExpr());
+}
+
+template<typename P_expr>
+inline bool any(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_any(expr);
+}
+
+template<typename P_numtype>
+inline bool any(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_any(x._bz_asVecExpr());
+}
+
+template<typename P_numtype, int N_dimensions>
+inline bool any(const TinyVector<P_numtype, N_dimensions>& x)
+{
+    return _bz_vec_any(x._bz_asVecExpr());
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECANY_CC
+
Index: /XMLIO_V2/external/include/blitz/vecbfn.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecbfn.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecbfn.cc	(revision 73)
@@ -0,0 +1,2586 @@
+/***************************************************************************
+ * blitz/../vecbfn.cc	Vector expression binary functions (2 operands)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-suggest@cybervision.com
+ * Bugs:                 blitz-bugs@cybervision.com
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://seurat.uwaterloo.ca/blitz/
+ *
+ ***************************************************************************
+ *
+ */ 
+
+// Generated source file.  Do not edit. 
+// genvecbfn.cpp Oct  6 2005 15:58:50
+
+#ifndef BZ_VECBFN_CC
+#define BZ_VECBFN_CC
+
+#ifndef BZ_VECEXPR_H
+ #error <blitz/vecbfn.cc> must be included via <blitz/vecexpr.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+/****************************************************************************
+ * Minimum Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> min Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> min _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype > > >
+min(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> min VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> min Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Min<P_numtype1, int > > >
+min(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> min TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> min int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Min<P_numtype1, int > > >
+min(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> min float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Min<P_numtype1, float > > >
+min(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Min<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> min double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Min<P_numtype1, double > > >
+min(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Min<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> min long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Min<P_numtype1, long double > > >
+min(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Min<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> min complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Min<P_numtype1, complex<T2>  > > >
+min(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Min<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> min Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2 > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> min _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> min VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2 > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> min Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Min<typename P_expr1::T_numtype, int > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Min<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> min TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2 > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> min int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Min<typename P_expr1::T_numtype, int > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Min<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> min float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Min<typename P_expr1::T_numtype, float > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Min<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> min double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Min<typename P_expr1::T_numtype, double > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Min<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> min long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Min<typename P_expr1::T_numtype, long double > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Min<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> min complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Min<typename P_expr1::T_numtype, complex<T2>  > > >
+min(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Min<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> min Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> min _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype > > >
+min(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> min VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> min Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Min<P_numtype1, int > > >
+min(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> min TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> min int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Min<P_numtype1, int > > >
+min(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> min float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Min<P_numtype1, float > > >
+min(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Min<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> min double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Min<P_numtype1, double > > >
+min(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Min<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> min long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Min<P_numtype1, long double > > >
+min(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Min<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> min complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Min<P_numtype1, complex<T2>  > > >
+min(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Min<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range min Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<int, P_numtype2 > > >
+min(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range min _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<int, typename P_expr2::T_numtype > > >
+min(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range min VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<int, P_numtype2 > > >
+min(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range min Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Min<int, int > > >
+min(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Min<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range min TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<int, P_numtype2 > > >
+min(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range min float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Min<int, float > > >
+min(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Min<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range min double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Min<int, double > > >
+min(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Min<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range min long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Min<int, long double > > >
+min(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Min<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range min complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Min<int, complex<T2>  > > >
+min(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Min<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> min Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> min _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> min VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> min Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Min<P_numtype1, int > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> min TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<P_numtype1, P_numtype2 > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> min int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Min<P_numtype1, int > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Min<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> min float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Min<P_numtype1, float > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Min<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> min double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Min<P_numtype1, double > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Min<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> min long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Min<P_numtype1, long double > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Min<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> min complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Min<P_numtype1, complex<T2>  > > >
+min(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Min<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int min Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<int, P_numtype2 > > >
+min(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int min _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<int, typename P_expr2::T_numtype > > >
+min(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int min VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<int, P_numtype2 > > >
+min(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int min TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<int, P_numtype2 > > >
+min(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float min Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<float, P_numtype2 > > >
+min(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float min _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<float, typename P_expr2::T_numtype > > >
+min(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float min VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<float, P_numtype2 > > >
+min(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float min Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Min<float, int > > >
+min(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Min<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float min TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<float, P_numtype2 > > >
+min(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double min Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<double, P_numtype2 > > >
+min(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double min _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<double, typename P_expr2::T_numtype > > >
+min(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double min VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<double, P_numtype2 > > >
+min(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double min Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Min<double, int > > >
+min(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Min<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double min TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<double, P_numtype2 > > >
+min(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double min Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<long double, P_numtype2 > > >
+min(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double min _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<long double, typename P_expr2::T_numtype > > >
+min(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double min VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<long double, P_numtype2 > > >
+min(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double min Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Min<long double, int > > >
+min(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Min<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double min TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<long double, P_numtype2 > > >
+min(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> min Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Min<complex<T1> , P_numtype2 > > >
+min(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Min<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> min _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Min<complex<T1> , typename P_expr2::T_numtype > > >
+min(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Min<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> min VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Min<complex<T1> , P_numtype2 > > >
+min(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Min<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> min Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Min<complex<T1> , int > > >
+min(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Min<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> min TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Min<complex<T1> , P_numtype2 > > >
+min(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Min<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Maximum Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> max Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> max _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype > > >
+max(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> max VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> max Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Max<P_numtype1, int > > >
+max(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> max TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> max int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Max<P_numtype1, int > > >
+max(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> max float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Max<P_numtype1, float > > >
+max(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Max<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> max double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Max<P_numtype1, double > > >
+max(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Max<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> max long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Max<P_numtype1, long double > > >
+max(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Max<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> max complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Max<P_numtype1, complex<T2>  > > >
+max(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Max<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> max Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2 > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> max _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> max VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2 > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> max Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Max<typename P_expr1::T_numtype, int > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Max<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> max TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2 > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> max int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Max<typename P_expr1::T_numtype, int > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Max<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> max float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Max<typename P_expr1::T_numtype, float > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Max<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> max double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Max<typename P_expr1::T_numtype, double > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Max<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> max long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Max<typename P_expr1::T_numtype, long double > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Max<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> max complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Max<typename P_expr1::T_numtype, complex<T2>  > > >
+max(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Max<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> max Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> max _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype > > >
+max(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> max VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> max Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Max<P_numtype1, int > > >
+max(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> max TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> max int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Max<P_numtype1, int > > >
+max(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> max float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Max<P_numtype1, float > > >
+max(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Max<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> max double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Max<P_numtype1, double > > >
+max(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Max<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> max long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Max<P_numtype1, long double > > >
+max(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Max<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> max complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Max<P_numtype1, complex<T2>  > > >
+max(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Max<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range max Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<int, P_numtype2 > > >
+max(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range max _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<int, typename P_expr2::T_numtype > > >
+max(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range max VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<int, P_numtype2 > > >
+max(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range max Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Max<int, int > > >
+max(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Max<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range max TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<int, P_numtype2 > > >
+max(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range max float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Max<int, float > > >
+max(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Max<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range max double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Max<int, double > > >
+max(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Max<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range max long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Max<int, long double > > >
+max(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Max<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range max complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Max<int, complex<T2>  > > >
+max(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Max<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> max Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> max _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> max VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> max Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Max<P_numtype1, int > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> max TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<P_numtype1, P_numtype2 > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> max int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Max<P_numtype1, int > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Max<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> max float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Max<P_numtype1, float > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Max<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> max double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Max<P_numtype1, double > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Max<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> max long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Max<P_numtype1, long double > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Max<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> max complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Max<P_numtype1, complex<T2>  > > >
+max(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Max<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int max Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<int, P_numtype2 > > >
+max(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int max _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<int, typename P_expr2::T_numtype > > >
+max(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int max VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<int, P_numtype2 > > >
+max(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int max TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<int, P_numtype2 > > >
+max(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float max Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<float, P_numtype2 > > >
+max(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float max _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<float, typename P_expr2::T_numtype > > >
+max(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float max VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<float, P_numtype2 > > >
+max(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float max Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Max<float, int > > >
+max(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Max<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float max TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<float, P_numtype2 > > >
+max(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double max Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<double, P_numtype2 > > >
+max(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double max _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<double, typename P_expr2::T_numtype > > >
+max(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double max VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<double, P_numtype2 > > >
+max(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double max Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Max<double, int > > >
+max(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Max<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double max TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<double, P_numtype2 > > >
+max(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double max Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<long double, P_numtype2 > > >
+max(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double max _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<long double, typename P_expr2::T_numtype > > >
+max(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double max VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<long double, P_numtype2 > > >
+max(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double max Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Max<long double, int > > >
+max(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Max<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double max TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<long double, P_numtype2 > > >
+max(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> max Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Max<complex<T1> , P_numtype2 > > >
+max(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Max<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> max _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Max<complex<T1> , typename P_expr2::T_numtype > > >
+max(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Max<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> max VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Max<complex<T1> , P_numtype2 > > >
+max(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Max<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> max Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Max<complex<T1> , int > > >
+max(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Max<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> max TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Max<complex<T1> , P_numtype2 > > >
+max(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Max<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/vecbops.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecbops.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecbops.cc	(revision 73)
@@ -0,0 +1,17290 @@
+/***************************************************************************
+ * blitz/../vecbops.cc	Vector expression templates (2 operands)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-suggest@cybervision.com
+ * Bugs:                 blitz-bugs@cybervision.com
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://seurat.uwaterloo.ca/blitz/
+ *
+ ***************************************************************************
+ *
+ */ 
+
+// Generated source file.  Do not edit. 
+// genvecbops.cpp Oct  6 2005 15:58:48
+
+#ifndef BZ_VECBOPS_CC
+#define BZ_VECBOPS_CC
+
+#ifndef BZ_VECEXPR_H
+ #error <blitz/vecbops.cc> must be included via <blitz/vecexpr.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+/****************************************************************************
+ * Addition Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> + Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> + _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype > > >
+operator+(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> + VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> + Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Add<P_numtype1, int > > >
+operator+(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> + TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> + int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Add<P_numtype1, int > > >
+operator+(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> + float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Add<P_numtype1, float > > >
+operator+(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Add<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> + double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Add<P_numtype1, double > > >
+operator+(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Add<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> + long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Add<P_numtype1, long double > > >
+operator+(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Add<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> + complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Add<P_numtype1, complex<T2>  > > >
+operator+(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Add<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> + Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2 > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> + _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> + VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2 > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> + Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Add<typename P_expr1::T_numtype, int > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Add<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> + TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2 > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> + int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Add<typename P_expr1::T_numtype, int > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Add<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> + float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Add<typename P_expr1::T_numtype, float > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Add<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> + double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Add<typename P_expr1::T_numtype, double > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Add<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> + long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Add<typename P_expr1::T_numtype, long double > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Add<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> + complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Add<typename P_expr1::T_numtype, complex<T2>  > > >
+operator+(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Add<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> + Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> + _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> + VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> + Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Add<P_numtype1, int > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> + TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> + int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Add<P_numtype1, int > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> + float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Add<P_numtype1, float > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Add<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> + double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Add<P_numtype1, double > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Add<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> + long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Add<P_numtype1, long double > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Add<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> + complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Add<P_numtype1, complex<T2>  > > >
+operator+(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Add<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range + Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range + _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<int, typename P_expr2::T_numtype > > >
+operator+(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range + VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range + Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Add<int, int > > >
+operator+(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Add<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range + TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range + float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Add<int, float > > >
+operator+(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Add<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range + double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Add<int, double > > >
+operator+(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Add<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range + long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Add<int, long double > > >
+operator+(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Add<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range + complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Add<int, complex<T2>  > > >
+operator+(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Add<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> + Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> + _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> + VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> + Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Add<P_numtype1, int > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> + TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<P_numtype1, P_numtype2 > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> + int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Add<P_numtype1, int > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Add<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> + float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Add<P_numtype1, float > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Add<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> + double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Add<P_numtype1, double > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Add<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> + long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Add<P_numtype1, long double > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Add<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> + complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Add<P_numtype1, complex<T2>  > > >
+operator+(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Add<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int + Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int + _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<int, typename P_expr2::T_numtype > > >
+operator+(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int + VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int + TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<int, P_numtype2 > > >
+operator+(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float + Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<float, P_numtype2 > > >
+operator+(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float + _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<float, typename P_expr2::T_numtype > > >
+operator+(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float + VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<float, P_numtype2 > > >
+operator+(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float + Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Add<float, int > > >
+operator+(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Add<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float + TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<float, P_numtype2 > > >
+operator+(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double + Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<double, P_numtype2 > > >
+operator+(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double + _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<double, typename P_expr2::T_numtype > > >
+operator+(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double + VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<double, P_numtype2 > > >
+operator+(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double + Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Add<double, int > > >
+operator+(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Add<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double + TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<double, P_numtype2 > > >
+operator+(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double + Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<long double, P_numtype2 > > >
+operator+(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double + _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<long double, typename P_expr2::T_numtype > > >
+operator+(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double + VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<long double, P_numtype2 > > >
+operator+(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double + Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Add<long double, int > > >
+operator+(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Add<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double + TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<long double, P_numtype2 > > >
+operator+(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Add<complex<T1> , P_numtype2 > > >
+operator+(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Add<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Add<complex<T1> , typename P_expr2::T_numtype > > >
+operator+(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Add<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Add<complex<T1> , P_numtype2 > > >
+operator+(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Add<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Add<complex<T1> , int > > >
+operator+(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Add<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> + TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Add<complex<T1> , P_numtype2 > > >
+operator+(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Add<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Subtraction Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> - Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> - _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > >
+operator-(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> - VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> - Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> - TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> - int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> - float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Subtract<P_numtype1, float > > >
+operator-(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Subtract<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> - double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Subtract<P_numtype1, double > > >
+operator-(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Subtract<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> - long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Subtract<P_numtype1, long double > > >
+operator-(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Subtract<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> - complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Subtract<P_numtype1, complex<T2>  > > >
+operator-(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Subtract<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> - Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> - _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> - VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> - Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Subtract<typename P_expr1::T_numtype, int > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Subtract<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> - TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> - int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Subtract<typename P_expr1::T_numtype, int > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Subtract<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> - float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Subtract<typename P_expr1::T_numtype, float > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Subtract<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> - double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Subtract<typename P_expr1::T_numtype, double > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Subtract<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> - long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Subtract<typename P_expr1::T_numtype, long double > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Subtract<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> - complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Subtract<typename P_expr1::T_numtype, complex<T2>  > > >
+operator-(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> - Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> - _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> - VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> - Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> - TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> - int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> - float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Subtract<P_numtype1, float > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Subtract<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> - double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Subtract<P_numtype1, double > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Subtract<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> - long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Subtract<P_numtype1, long double > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Subtract<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> - complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Subtract<P_numtype1, complex<T2>  > > >
+operator-(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Subtract<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range - Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range - _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<int, typename P_expr2::T_numtype > > >
+operator-(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range - VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range - Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Subtract<int, int > > >
+operator-(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Subtract<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range - TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range - float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Subtract<int, float > > >
+operator-(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Subtract<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range - double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Subtract<int, double > > >
+operator-(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Subtract<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range - long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Subtract<int, long double > > >
+operator-(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Subtract<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range - complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Subtract<int, complex<T2>  > > >
+operator-(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Subtract<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> - Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> - _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> - VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> - Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> - TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<P_numtype1, P_numtype2 > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> - int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Subtract<P_numtype1, int > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Subtract<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> - float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Subtract<P_numtype1, float > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Subtract<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> - double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Subtract<P_numtype1, double > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Subtract<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> - long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Subtract<P_numtype1, long double > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Subtract<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> - complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Subtract<P_numtype1, complex<T2>  > > >
+operator-(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Subtract<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int - Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int - _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<int, typename P_expr2::T_numtype > > >
+operator-(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int - VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int - TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<int, P_numtype2 > > >
+operator-(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float - Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<float, P_numtype2 > > >
+operator-(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float - _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<float, typename P_expr2::T_numtype > > >
+operator-(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float - VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<float, P_numtype2 > > >
+operator-(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float - Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Subtract<float, int > > >
+operator-(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Subtract<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float - TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<float, P_numtype2 > > >
+operator-(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double - Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<double, P_numtype2 > > >
+operator-(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double - _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<double, typename P_expr2::T_numtype > > >
+operator-(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double - VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<double, P_numtype2 > > >
+operator-(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double - Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Subtract<double, int > > >
+operator-(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Subtract<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double - TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<double, P_numtype2 > > >
+operator-(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double - Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<long double, P_numtype2 > > >
+operator-(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double - _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<long double, typename P_expr2::T_numtype > > >
+operator-(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double - VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<long double, P_numtype2 > > >
+operator-(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double - Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Subtract<long double, int > > >
+operator-(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Subtract<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double - TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<long double, P_numtype2 > > >
+operator-(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Subtract<complex<T1> , P_numtype2 > > >
+operator-(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Subtract<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Subtract<complex<T1> , typename P_expr2::T_numtype > > >
+operator-(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Subtract<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Subtract<complex<T1> , P_numtype2 > > >
+operator-(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Subtract<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Subtract<complex<T1> , int > > >
+operator-(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Subtract<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> - TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Subtract<complex<T1> , P_numtype2 > > >
+operator-(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Subtract<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Multiplication Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> * Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> * _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > >
+operator*(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> * VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> * Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> * TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> * int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> * float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Multiply<P_numtype1, float > > >
+operator*(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Multiply<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> * double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Multiply<P_numtype1, double > > >
+operator*(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Multiply<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> * long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Multiply<P_numtype1, long double > > >
+operator*(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Multiply<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> * complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Multiply<P_numtype1, complex<T2>  > > >
+operator*(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Multiply<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> * Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> * _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> * VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> * Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Multiply<typename P_expr1::T_numtype, int > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Multiply<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> * TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> * int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Multiply<typename P_expr1::T_numtype, int > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Multiply<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> * float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Multiply<typename P_expr1::T_numtype, float > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Multiply<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> * double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Multiply<typename P_expr1::T_numtype, double > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Multiply<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> * long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Multiply<typename P_expr1::T_numtype, long double > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Multiply<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> * complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Multiply<typename P_expr1::T_numtype, complex<T2>  > > >
+operator*(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> * Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> * _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> * VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> * Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> * TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> * int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> * float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Multiply<P_numtype1, float > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Multiply<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> * double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Multiply<P_numtype1, double > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Multiply<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> * long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Multiply<P_numtype1, long double > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Multiply<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> * complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Multiply<P_numtype1, complex<T2>  > > >
+operator*(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Multiply<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range * Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range * _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<int, typename P_expr2::T_numtype > > >
+operator*(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range * VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range * Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Multiply<int, int > > >
+operator*(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Multiply<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range * TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range * float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Multiply<int, float > > >
+operator*(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Multiply<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range * double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Multiply<int, double > > >
+operator*(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Multiply<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range * long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Multiply<int, long double > > >
+operator*(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Multiply<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range * complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Multiply<int, complex<T2>  > > >
+operator*(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Multiply<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> * Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> * _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> * VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> * Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> * TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<P_numtype1, P_numtype2 > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> * int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Multiply<P_numtype1, int > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Multiply<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> * float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Multiply<P_numtype1, float > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Multiply<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> * double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Multiply<P_numtype1, double > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Multiply<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> * long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Multiply<P_numtype1, long double > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Multiply<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> * complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Multiply<P_numtype1, complex<T2>  > > >
+operator*(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Multiply<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int * Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int * _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<int, typename P_expr2::T_numtype > > >
+operator*(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int * VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int * TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<int, P_numtype2 > > >
+operator*(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float * Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<float, P_numtype2 > > >
+operator*(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float * _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<float, typename P_expr2::T_numtype > > >
+operator*(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float * VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<float, P_numtype2 > > >
+operator*(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float * Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Multiply<float, int > > >
+operator*(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Multiply<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float * TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<float, P_numtype2 > > >
+operator*(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double * Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<double, P_numtype2 > > >
+operator*(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double * _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<double, typename P_expr2::T_numtype > > >
+operator*(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double * VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<double, P_numtype2 > > >
+operator*(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double * Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Multiply<double, int > > >
+operator*(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Multiply<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double * TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<double, P_numtype2 > > >
+operator*(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double * Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<long double, P_numtype2 > > >
+operator*(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double * _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<long double, typename P_expr2::T_numtype > > >
+operator*(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double * VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<long double, P_numtype2 > > >
+operator*(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double * Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Multiply<long double, int > > >
+operator*(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Multiply<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double * TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<long double, P_numtype2 > > >
+operator*(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Multiply<complex<T1> , P_numtype2 > > >
+operator*(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Multiply<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Multiply<complex<T1> , typename P_expr2::T_numtype > > >
+operator*(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Multiply<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Multiply<complex<T1> , P_numtype2 > > >
+operator*(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Multiply<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Multiply<complex<T1> , int > > >
+operator*(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Multiply<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> * TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Multiply<complex<T1> , P_numtype2 > > >
+operator*(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Multiply<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Division Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> / Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> / _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype > > >
+operator/(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> / VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> / Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> / TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> / int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> / float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Divide<P_numtype1, float > > >
+operator/(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Divide<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> / double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Divide<P_numtype1, double > > >
+operator/(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Divide<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> / long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Divide<P_numtype1, long double > > >
+operator/(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Divide<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> / complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Divide<P_numtype1, complex<T2>  > > >
+operator/(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Divide<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> / Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> / _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> / VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> / Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Divide<typename P_expr1::T_numtype, int > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Divide<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> / TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> / int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Divide<typename P_expr1::T_numtype, int > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Divide<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> / float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Divide<typename P_expr1::T_numtype, float > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Divide<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> / double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Divide<typename P_expr1::T_numtype, double > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Divide<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> / long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Divide<typename P_expr1::T_numtype, long double > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Divide<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> / complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Divide<typename P_expr1::T_numtype, complex<T2>  > > >
+operator/(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Divide<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> / Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> / _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> / VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> / Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> / TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> / int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> / float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Divide<P_numtype1, float > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Divide<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> / double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Divide<P_numtype1, double > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Divide<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> / long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Divide<P_numtype1, long double > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Divide<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> / complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Divide<P_numtype1, complex<T2>  > > >
+operator/(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Divide<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range / Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range / _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<int, typename P_expr2::T_numtype > > >
+operator/(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range / VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range / Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Divide<int, int > > >
+operator/(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Divide<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range / TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range / float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Divide<int, float > > >
+operator/(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Divide<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range / double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Divide<int, double > > >
+operator/(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Divide<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range / long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Divide<int, long double > > >
+operator/(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Divide<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range / complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Divide<int, complex<T2>  > > >
+operator/(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Divide<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> / Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> / _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> / VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> / Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> / TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<P_numtype1, P_numtype2 > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> / int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Divide<P_numtype1, int > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Divide<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> / float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Divide<P_numtype1, float > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Divide<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> / double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Divide<P_numtype1, double > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Divide<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> / long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Divide<P_numtype1, long double > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Divide<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> / complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Divide<P_numtype1, complex<T2>  > > >
+operator/(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Divide<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int / Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int / _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<int, typename P_expr2::T_numtype > > >
+operator/(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int / VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int / TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<int, P_numtype2 > > >
+operator/(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float / Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<float, P_numtype2 > > >
+operator/(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float / _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<float, typename P_expr2::T_numtype > > >
+operator/(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float / VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<float, P_numtype2 > > >
+operator/(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float / Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Divide<float, int > > >
+operator/(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Divide<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float / TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<float, P_numtype2 > > >
+operator/(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double / Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<double, P_numtype2 > > >
+operator/(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double / _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<double, typename P_expr2::T_numtype > > >
+operator/(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double / VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<double, P_numtype2 > > >
+operator/(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double / Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Divide<double, int > > >
+operator/(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Divide<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double / TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<double, P_numtype2 > > >
+operator/(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double / Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<long double, P_numtype2 > > >
+operator/(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double / _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<long double, typename P_expr2::T_numtype > > >
+operator/(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double / VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<long double, P_numtype2 > > >
+operator/(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double / Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Divide<long double, int > > >
+operator/(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Divide<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double / TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<long double, P_numtype2 > > >
+operator/(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Divide<complex<T1> , P_numtype2 > > >
+operator/(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Divide<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Divide<complex<T1> , typename P_expr2::T_numtype > > >
+operator/(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Divide<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Divide<complex<T1> , P_numtype2 > > >
+operator/(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Divide<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Divide<complex<T1> , int > > >
+operator/(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Divide<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> / TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Divide<complex<T1> , P_numtype2 > > >
+operator/(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Divide<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Modulus Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> % Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> % _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype > > >
+operator%(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> % VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> % Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> % TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> % int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> % Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> % _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> % VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> % Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Mod<typename P_expr1::T_numtype, int > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Mod<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> % TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> % int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Mod<typename P_expr1::T_numtype, int > > >
+operator%(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Mod<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> % Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> % _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> % VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> % Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> % TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> % int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range % Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range % _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<int, typename P_expr2::T_numtype > > >
+operator%(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range % VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range % Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Mod<int, int > > >
+operator%(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Mod<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range % TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> % Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> % _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> % VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> % Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> % TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<P_numtype1, P_numtype2 > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> % int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Mod<P_numtype1, int > > >
+operator%(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Mod<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int % Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int % _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Mod<int, typename P_expr2::T_numtype > > >
+operator%(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Mod<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int % VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int % TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Mod<int, P_numtype2 > > >
+operator%(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Mod<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Bitwise XOR Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> ^ Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> ^ _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > >
+operator^(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> ^ VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> ^ Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> ^ TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> ^ int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> ^ Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> ^ _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> ^ VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> ^ Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> ^ TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> ^ int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int > > >
+operator^(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseXOR<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> ^ Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> ^ _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> ^ VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> ^ Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> ^ TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> ^ int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range ^ Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range ^ _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype > > >
+operator^(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range ^ VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range ^ Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_BitwiseXOR<int, int > > >
+operator^(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_BitwiseXOR<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range ^ TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> ^ int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseXOR<P_numtype1, int > > >
+operator^(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseXOR<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int ^ Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int ^ _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype > > >
+operator^(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseXOR<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int ^ VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int ^ TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseXOR<int, P_numtype2 > > >
+operator^(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseXOR<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Bitwise And Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> & Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> & _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> & VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> & Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> & TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> & int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> & Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> & _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> & VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> & Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> & TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> & int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int > > >
+operator&(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> & Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> & _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> & VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> & Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> & TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> & int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range & Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range & _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype > > >
+operator&(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range & VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range & Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_BitwiseAnd<int, int > > >
+operator&(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_BitwiseAnd<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range & TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> & Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> & _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> & VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> & Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> & TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> & int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseAnd<P_numtype1, int > > >
+operator&(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int & Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int & _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype > > >
+operator&(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int & VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int & TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseAnd<int, P_numtype2 > > >
+operator&(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Bitwise Or Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> | Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> | _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator|(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> | VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> | Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> | TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> | int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> | Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> | _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> | VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> | Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> | TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> | int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int > > >
+operator|(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> | Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> | _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> | VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> | Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> | TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> | int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range | Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range | _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype > > >
+operator|(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range | VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range | Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_BitwiseOr<int, int > > >
+operator|(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_BitwiseOr<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range | TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> | Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> | _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> | VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> | Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> | TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<P_numtype1, P_numtype2 > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> | int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_BitwiseOr<P_numtype1, int > > >
+operator|(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_BitwiseOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int | Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int | _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype > > >
+operator|(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_BitwiseOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int | VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int | TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_BitwiseOr<int, P_numtype2 > > >
+operator|(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_BitwiseOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Shift right Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> >> Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >> _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> >> VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >> Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> >> TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >> int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> >> Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >> _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> >> VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >> Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_ShiftRight<typename P_expr1::T_numtype, int > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> >> TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >> int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftRight<typename P_expr1::T_numtype, int > > >
+operator>>(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftRight<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> >> Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >> _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> >> VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >> Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> >> TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >> int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range >> Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range >> _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<int, typename P_expr2::T_numtype > > >
+operator>>(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range >> VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range >> Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_ShiftRight<int, int > > >
+operator>>(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_ShiftRight<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range >> TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >> Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >> _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> >> VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >> Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> >> TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<P_numtype1, P_numtype2 > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >> int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftRight<P_numtype1, int > > >
+operator>>(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftRight<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int >> Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int >> _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftRight<int, typename P_expr2::T_numtype > > >
+operator>>(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftRight<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int >> VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int >> TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftRight<int, P_numtype2 > > >
+operator>>(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftRight<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Shift left Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> << Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> << _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> << VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> << Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> << TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> << int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> << Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> << _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> << VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> << Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> << TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> << int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int > > >
+operator<<(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftLeft<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> << Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> << _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> << VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> << Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> << TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> << int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range << Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range << _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype > > >
+operator<<(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range << VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range << Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_ShiftLeft<int, int > > >
+operator<<(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_ShiftLeft<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range << TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> << Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> << _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> << VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> << Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> << TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<P_numtype1, P_numtype2 > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> << int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_ShiftLeft<P_numtype1, int > > >
+operator<<(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_ShiftLeft<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int << Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int << _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype > > >
+operator<<(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_ShiftLeft<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int << VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int << TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_ShiftLeft<int, P_numtype2 > > >
+operator<<(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_ShiftLeft<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Greater-than Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> > Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> > _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype > > >
+operator>(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> > VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> > Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> > TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> > int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> > float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Greater<P_numtype1, float > > >
+operator>(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Greater<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> > double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Greater<P_numtype1, double > > >
+operator>(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Greater<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> > long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Greater<P_numtype1, long double > > >
+operator>(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Greater<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> > complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Greater<P_numtype1, complex<T2>  > > >
+operator>(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Greater<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> > Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> > _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> > VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> > Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Greater<typename P_expr1::T_numtype, int > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Greater<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> > TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> > int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Greater<typename P_expr1::T_numtype, int > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Greater<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> > float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Greater<typename P_expr1::T_numtype, float > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Greater<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> > double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Greater<typename P_expr1::T_numtype, double > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Greater<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> > long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Greater<typename P_expr1::T_numtype, long double > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Greater<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> > complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Greater<typename P_expr1::T_numtype, complex<T2>  > > >
+operator>(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Greater<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> > Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> > _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> > VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> > Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> > TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> > int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> > float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Greater<P_numtype1, float > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Greater<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> > double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Greater<P_numtype1, double > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Greater<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> > long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Greater<P_numtype1, long double > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Greater<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> > complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Greater<P_numtype1, complex<T2>  > > >
+operator>(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Greater<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range > Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range > _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<int, typename P_expr2::T_numtype > > >
+operator>(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range > VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range > Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Greater<int, int > > >
+operator>(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Greater<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range > TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range > float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Greater<int, float > > >
+operator>(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Greater<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range > double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Greater<int, double > > >
+operator>(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Greater<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range > long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Greater<int, long double > > >
+operator>(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Greater<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range > complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Greater<int, complex<T2>  > > >
+operator>(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Greater<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> > Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> > _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> > VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> > Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> > TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<P_numtype1, P_numtype2 > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> > int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Greater<P_numtype1, int > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Greater<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> > float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Greater<P_numtype1, float > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Greater<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> > double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Greater<P_numtype1, double > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Greater<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> > long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Greater<P_numtype1, long double > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Greater<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> > complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Greater<P_numtype1, complex<T2>  > > >
+operator>(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Greater<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int > Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int > _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<int, typename P_expr2::T_numtype > > >
+operator>(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int > VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int > TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<int, P_numtype2 > > >
+operator>(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float > Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<float, P_numtype2 > > >
+operator>(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float > _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<float, typename P_expr2::T_numtype > > >
+operator>(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float > VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<float, P_numtype2 > > >
+operator>(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float > Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Greater<float, int > > >
+operator>(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Greater<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float > TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<float, P_numtype2 > > >
+operator>(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double > Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<double, P_numtype2 > > >
+operator>(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double > _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<double, typename P_expr2::T_numtype > > >
+operator>(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double > VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<double, P_numtype2 > > >
+operator>(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double > Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Greater<double, int > > >
+operator>(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Greater<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double > TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<double, P_numtype2 > > >
+operator>(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double > Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<long double, P_numtype2 > > >
+operator>(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double > _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<long double, typename P_expr2::T_numtype > > >
+operator>(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double > VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<long double, P_numtype2 > > >
+operator>(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double > Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Greater<long double, int > > >
+operator>(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Greater<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double > TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<long double, P_numtype2 > > >
+operator>(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Greater<complex<T1> , P_numtype2 > > >
+operator>(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Greater<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Greater<complex<T1> , typename P_expr2::T_numtype > > >
+operator>(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Greater<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Greater<complex<T1> , P_numtype2 > > >
+operator>(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Greater<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Greater<complex<T1> , int > > >
+operator>(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Greater<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> > TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Greater<complex<T1> , P_numtype2 > > >
+operator>(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Greater<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Less-than Operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> < Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> < _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype > > >
+operator<(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> < VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> < Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Less<P_numtype1, int > > >
+operator<(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> < TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> < int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Less<P_numtype1, int > > >
+operator<(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> < float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Less<P_numtype1, float > > >
+operator<(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Less<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> < double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Less<P_numtype1, double > > >
+operator<(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Less<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> < long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Less<P_numtype1, long double > > >
+operator<(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Less<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> < complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Less<P_numtype1, complex<T2>  > > >
+operator<(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Less<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> < Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> < _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> < VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> < Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Less<typename P_expr1::T_numtype, int > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Less<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> < TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> < int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Less<typename P_expr1::T_numtype, int > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Less<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> < float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Less<typename P_expr1::T_numtype, float > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Less<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> < double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Less<typename P_expr1::T_numtype, double > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Less<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> < long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Less<typename P_expr1::T_numtype, long double > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Less<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> < complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Less<typename P_expr1::T_numtype, complex<T2>  > > >
+operator<(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Less<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> < Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> < _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> < VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> < Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Less<P_numtype1, int > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> < TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> < int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Less<P_numtype1, int > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> < float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Less<P_numtype1, float > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Less<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> < double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Less<P_numtype1, double > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Less<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> < long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Less<P_numtype1, long double > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Less<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> < complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Less<P_numtype1, complex<T2>  > > >
+operator<(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Less<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range < Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range < _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<int, typename P_expr2::T_numtype > > >
+operator<(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range < VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range < Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Less<int, int > > >
+operator<(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Less<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range < TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range < float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Less<int, float > > >
+operator<(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Less<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range < double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Less<int, double > > >
+operator<(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Less<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range < long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Less<int, long double > > >
+operator<(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Less<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range < complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Less<int, complex<T2>  > > >
+operator<(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Less<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> < Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> < _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> < VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> < Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Less<P_numtype1, int > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> < TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<P_numtype1, P_numtype2 > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> < int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Less<P_numtype1, int > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Less<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> < float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Less<P_numtype1, float > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Less<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> < double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Less<P_numtype1, double > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Less<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> < long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Less<P_numtype1, long double > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Less<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> < complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Less<P_numtype1, complex<T2>  > > >
+operator<(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Less<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int < Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int < _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<int, typename P_expr2::T_numtype > > >
+operator<(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int < VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int < TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<int, P_numtype2 > > >
+operator<(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float < Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<float, P_numtype2 > > >
+operator<(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float < _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<float, typename P_expr2::T_numtype > > >
+operator<(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float < VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<float, P_numtype2 > > >
+operator<(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float < Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Less<float, int > > >
+operator<(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Less<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float < TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<float, P_numtype2 > > >
+operator<(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double < Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<double, P_numtype2 > > >
+operator<(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double < _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<double, typename P_expr2::T_numtype > > >
+operator<(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double < VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<double, P_numtype2 > > >
+operator<(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double < Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Less<double, int > > >
+operator<(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Less<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double < TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<double, P_numtype2 > > >
+operator<(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double < Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<long double, P_numtype2 > > >
+operator<(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double < _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<long double, typename P_expr2::T_numtype > > >
+operator<(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double < VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<long double, P_numtype2 > > >
+operator<(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double < Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Less<long double, int > > >
+operator<(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Less<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double < TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<long double, P_numtype2 > > >
+operator<(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Less<complex<T1> , P_numtype2 > > >
+operator<(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Less<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Less<complex<T1> , typename P_expr2::T_numtype > > >
+operator<(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Less<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Less<complex<T1> , P_numtype2 > > >
+operator<(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Less<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Less<complex<T1> , int > > >
+operator<(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Less<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> < TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Less<complex<T1> , P_numtype2 > > >
+operator<(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Less<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Greater or equal (>=) operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> >= Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >= _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> >= VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >= Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> >= int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> >= float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_GreaterOrEqual<P_numtype1, float > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_GreaterOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> >= double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_GreaterOrEqual<P_numtype1, double > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_GreaterOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> >= long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_GreaterOrEqual<P_numtype1, long double > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_GreaterOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> >= complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<P_numtype1, complex<T2>  > > >
+operator>=(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> >= Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >= _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> >= VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >= Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> >= TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> >= int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> >= float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, float > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> >= double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, double > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> >= long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> >= complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator>=(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> >= Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >= _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> >= VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >= Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> >= int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> >= float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_GreaterOrEqual<P_numtype1, float > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_GreaterOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> >= double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_GreaterOrEqual<P_numtype1, double > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_GreaterOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> >= long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_GreaterOrEqual<P_numtype1, long double > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_GreaterOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> >= complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<P_numtype1, complex<T2>  > > >
+operator>=(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range >= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range >= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype > > >
+operator>=(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range >= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range >= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_GreaterOrEqual<int, int > > >
+operator>=(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_GreaterOrEqual<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range >= float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_GreaterOrEqual<int, float > > >
+operator>=(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_GreaterOrEqual<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range >= double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_GreaterOrEqual<int, double > > >
+operator>=(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_GreaterOrEqual<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range >= long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_GreaterOrEqual<int, long double > > >
+operator>=(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_GreaterOrEqual<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range >= complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<int, complex<T2>  > > >
+operator>=(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> >= Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >= _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> >= VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >= Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> >= int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_GreaterOrEqual<P_numtype1, int > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_GreaterOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> >= float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_GreaterOrEqual<P_numtype1, float > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_GreaterOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> >= double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_GreaterOrEqual<P_numtype1, double > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_GreaterOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> >= long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_GreaterOrEqual<P_numtype1, long double > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_GreaterOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> >= complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_GreaterOrEqual<P_numtype1, complex<T2>  > > >
+operator>=(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_GreaterOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int >= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int >= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype > > >
+operator>=(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int >= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<int, P_numtype2 > > >
+operator>=(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float >= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<float, P_numtype2 > > >
+operator>=(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float >= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<float, typename P_expr2::T_numtype > > >
+operator>=(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float >= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<float, P_numtype2 > > >
+operator>=(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float >= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_GreaterOrEqual<float, int > > >
+operator>=(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_GreaterOrEqual<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<float, P_numtype2 > > >
+operator>=(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double >= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<double, P_numtype2 > > >
+operator>=(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double >= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<double, typename P_expr2::T_numtype > > >
+operator>=(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double >= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<double, P_numtype2 > > >
+operator>=(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double >= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_GreaterOrEqual<double, int > > >
+operator>=(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_GreaterOrEqual<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<double, P_numtype2 > > >
+operator>=(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double >= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<long double, P_numtype2 > > >
+operator>=(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double >= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype > > >
+operator>=(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double >= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<long double, P_numtype2 > > >
+operator>=(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double >= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_GreaterOrEqual<long double, int > > >
+operator>=(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_GreaterOrEqual<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double >= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<long double, P_numtype2 > > >
+operator>=(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2 > > >
+operator>=(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator>=(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2 > > >
+operator>=(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_GreaterOrEqual<complex<T1> , int > > >
+operator>=(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_GreaterOrEqual<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> >= TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2 > > >
+operator>=(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_GreaterOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Less or equal (<=) operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> <= Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> <= _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> <= VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> <= Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> <= int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> <= float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_LessOrEqual<P_numtype1, float > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_LessOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> <= double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_LessOrEqual<P_numtype1, double > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_LessOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> <= long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_LessOrEqual<P_numtype1, long double > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_LessOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> <= complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<P_numtype1, complex<T2>  > > >
+operator<=(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> <= Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> <= _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> <= VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> <= Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> <= TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> <= int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> <= float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, float > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> <= double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, double > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> <= long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, long double > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> <= complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator<=(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> <= Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> <= _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> <= VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> <= Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> <= int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> <= float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_LessOrEqual<P_numtype1, float > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_LessOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> <= double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_LessOrEqual<P_numtype1, double > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_LessOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> <= long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_LessOrEqual<P_numtype1, long double > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_LessOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> <= complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<P_numtype1, complex<T2>  > > >
+operator<=(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range <= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range <= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype > > >
+operator<=(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range <= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range <= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_LessOrEqual<int, int > > >
+operator<=(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_LessOrEqual<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range <= float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_LessOrEqual<int, float > > >
+operator<=(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_LessOrEqual<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range <= double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_LessOrEqual<int, double > > >
+operator<=(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_LessOrEqual<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range <= long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_LessOrEqual<int, long double > > >
+operator<=(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_LessOrEqual<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range <= complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<int, complex<T2>  > > >
+operator<=(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> <= Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> <= _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> <= VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> <= Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<P_numtype1, P_numtype2 > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> <= int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LessOrEqual<P_numtype1, int > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LessOrEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> <= float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_LessOrEqual<P_numtype1, float > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_LessOrEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> <= double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_LessOrEqual<P_numtype1, double > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_LessOrEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> <= long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_LessOrEqual<P_numtype1, long double > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_LessOrEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> <= complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_LessOrEqual<P_numtype1, complex<T2>  > > >
+operator<=(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_LessOrEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int <= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int <= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype > > >
+operator<=(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int <= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<int, P_numtype2 > > >
+operator<=(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float <= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<float, P_numtype2 > > >
+operator<=(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float <= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<float, typename P_expr2::T_numtype > > >
+operator<=(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float <= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<float, P_numtype2 > > >
+operator<=(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float <= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_LessOrEqual<float, int > > >
+operator<=(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_LessOrEqual<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<float, P_numtype2 > > >
+operator<=(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double <= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<double, P_numtype2 > > >
+operator<=(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double <= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<double, typename P_expr2::T_numtype > > >
+operator<=(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double <= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<double, P_numtype2 > > >
+operator<=(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double <= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_LessOrEqual<double, int > > >
+operator<=(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_LessOrEqual<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<double, P_numtype2 > > >
+operator<=(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double <= Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<long double, P_numtype2 > > >
+operator<=(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double <= _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<long double, typename P_expr2::T_numtype > > >
+operator<=(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double <= VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<long double, P_numtype2 > > >
+operator<=(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double <= Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_LessOrEqual<long double, int > > >
+operator<=(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_LessOrEqual<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double <= TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<long double, P_numtype2 > > >
+operator<=(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_LessOrEqual<complex<T1> , P_numtype2 > > >
+operator<=(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_LessOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator<=(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LessOrEqual<complex<T1> , P_numtype2 > > >
+operator<=(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LessOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_LessOrEqual<complex<T1> , int > > >
+operator<=(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_LessOrEqual<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> <= TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LessOrEqual<complex<T1> , P_numtype2 > > >
+operator<=(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LessOrEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Equality operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> == Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> == _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype > > >
+operator==(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> == VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> == Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> == TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> == int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> == float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Equal<P_numtype1, float > > >
+operator==(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Equal<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> == double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Equal<P_numtype1, double > > >
+operator==(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Equal<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> == long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Equal<P_numtype1, long double > > >
+operator==(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Equal<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> == complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Equal<P_numtype1, complex<T2>  > > >
+operator==(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Equal<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> == Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> == _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> == VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> == Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_Equal<typename P_expr1::T_numtype, int > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_Equal<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> == TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> == int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Equal<typename P_expr1::T_numtype, int > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Equal<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> == float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Equal<typename P_expr1::T_numtype, float > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Equal<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> == double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Equal<typename P_expr1::T_numtype, double > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Equal<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> == long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Equal<typename P_expr1::T_numtype, long double > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Equal<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> == complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Equal<typename P_expr1::T_numtype, complex<T2>  > > >
+operator==(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Equal<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> == Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> == _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> == VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> == Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> == TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> == int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> == float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Equal<P_numtype1, float > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Equal<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> == double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Equal<P_numtype1, double > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Equal<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> == long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Equal<P_numtype1, long double > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Equal<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> == complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Equal<P_numtype1, complex<T2>  > > >
+operator==(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Equal<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range == Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range == _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<int, typename P_expr2::T_numtype > > >
+operator==(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range == VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range == Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_Equal<int, int > > >
+operator==(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_Equal<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range == TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range == float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_Equal<int, float > > >
+operator==(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_Equal<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range == double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_Equal<int, double > > >
+operator==(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_Equal<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range == long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_Equal<int, long double > > >
+operator==(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Equal<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range == complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Equal<int, complex<T2>  > > >
+operator==(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Equal<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> == Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> == _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> == VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> == Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> == TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<P_numtype1, P_numtype2 > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> == int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_Equal<P_numtype1, int > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_Equal<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> == float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_Equal<P_numtype1, float > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_Equal<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> == double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_Equal<P_numtype1, double > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_Equal<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> == long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_Equal<P_numtype1, long double > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_Equal<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> == complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_Equal<P_numtype1, complex<T2>  > > >
+operator==(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_Equal<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int == Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int == _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<int, typename P_expr2::T_numtype > > >
+operator==(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int == VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int == TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<int, P_numtype2 > > >
+operator==(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float == Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<float, P_numtype2 > > >
+operator==(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float == _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<float, typename P_expr2::T_numtype > > >
+operator==(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float == VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<float, P_numtype2 > > >
+operator==(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float == Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_Equal<float, int > > >
+operator==(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_Equal<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float == TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<float, P_numtype2 > > >
+operator==(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double == Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<double, P_numtype2 > > >
+operator==(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double == _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<double, typename P_expr2::T_numtype > > >
+operator==(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double == VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<double, P_numtype2 > > >
+operator==(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double == Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_Equal<double, int > > >
+operator==(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_Equal<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double == TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<double, P_numtype2 > > >
+operator==(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double == Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<long double, P_numtype2 > > >
+operator==(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double == _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<long double, typename P_expr2::T_numtype > > >
+operator==(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double == VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<long double, P_numtype2 > > >
+operator==(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double == Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_Equal<long double, int > > >
+operator==(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_Equal<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double == TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<long double, P_numtype2 > > >
+operator==(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_Equal<complex<T1> , P_numtype2 > > >
+operator==(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_Equal<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_Equal<complex<T1> , typename P_expr2::T_numtype > > >
+operator==(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_Equal<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_Equal<complex<T1> , P_numtype2 > > >
+operator==(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_Equal<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_Equal<complex<T1> , int > > >
+operator==(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_Equal<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> == TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_Equal<complex<T1> , P_numtype2 > > >
+operator==(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_Equal<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Not-equal operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> != Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> != _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> != VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> != Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> != TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> != int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Vector<P_numtype1> != float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_NotEqual<P_numtype1, float > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_NotEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Vector<P_numtype1> != double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_NotEqual<P_numtype1, double > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_NotEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Vector<P_numtype1> != long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_NotEqual<P_numtype1, long double > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_NotEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Vector<P_numtype1> != complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_NotEqual<P_numtype1, complex<T2>  > > >
+operator!=(const Vector<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_NotEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// _bz_VecExpr<P_expr1> != Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> != _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> != VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> != Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_NotEqual<typename P_expr1::T_numtype, int > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_NotEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> != TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> != int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_NotEqual<typename P_expr1::T_numtype, int > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> != float
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>,
+      _bz_NotEqual<typename P_expr1::T_numtype, float > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> != double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>,
+      _bz_NotEqual<typename P_expr1::T_numtype, double > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> != long double
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_NotEqual<typename P_expr1::T_numtype, long double > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_NotEqual<typename P_expr1::T_numtype, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// _bz_VecExpr<P_expr1> != complex<T2>
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_NotEqual<typename P_expr1::T_numtype, complex<T2>  > > >
+operator!=(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// VectorPick<P_numtype1> != Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> != _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> != VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> != Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> != TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> != int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> != float
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>,
+      _bz_NotEqual<P_numtype1, float > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_NotEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// VectorPick<P_numtype1> != double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>,
+      _bz_NotEqual<P_numtype1, double > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_NotEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// VectorPick<P_numtype1> != long double
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_NotEqual<P_numtype1, long double > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_NotEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// VectorPick<P_numtype1> != complex<T2>
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_NotEqual<P_numtype1, complex<T2>  > > >
+operator!=(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_NotEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// Range != Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range != _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<int, typename P_expr2::T_numtype > > >
+operator!=(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range != VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range != Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_NotEqual<int, int > > >
+operator!=(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_NotEqual<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range != TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range != float
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>,
+      _bz_NotEqual<int, float > > >
+operator!=(Range d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_NotEqual<int, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// Range != double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>,
+      _bz_NotEqual<int, double > > >
+operator!=(Range d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_NotEqual<int, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// Range != long double
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>,
+      _bz_NotEqual<int, long double > > >
+operator!=(Range d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_NotEqual<int, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// Range != complex<T2>
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_NotEqual<int, complex<T2>  > > >
+operator!=(Range d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_NotEqual<int, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// TinyVector<P_numtype1, N_length1> != Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> != _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> != VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> != Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> != TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<P_numtype1, P_numtype2 > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> != int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_NotEqual<P_numtype1, int > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_NotEqual<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> != float
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>,
+      _bz_NotEqual<P_numtype1, float > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_NotEqual<P_numtype1, float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> != double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>,
+      _bz_NotEqual<P_numtype1, double > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_NotEqual<P_numtype1, double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2)));
+}
+
+// TinyVector<P_numtype1, N_length1> != long double
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>,
+      _bz_NotEqual<P_numtype1, long double > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_NotEqual<P_numtype1, long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2)));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// TinyVector<P_numtype1, N_length1> != complex<T2>
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > ,
+      _bz_NotEqual<P_numtype1, complex<T2>  > > >
+operator!=(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_NotEqual<P_numtype1, complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+
+// int != Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int != _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<int, typename P_expr2::T_numtype > > >
+operator!=(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int != VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int != TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<int, P_numtype2 > > >
+operator!=(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// float != Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<float, P_numtype2 > > >
+operator!=(float d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float != _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<float, typename P_expr2::T_numtype > > >
+operator!=(float d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<float, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float != VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<float, P_numtype2 > > >
+operator!=(float d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// float != Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range,
+      _bz_NotEqual<float, int > > >
+operator!=(float d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      Range, 
+      _bz_NotEqual<float, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2));
+}
+
+// float != TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<float, P_numtype2 > > >
+operator!=(float d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<float, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), 
+      d2.beginFast()));
+}
+
+// double != Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<double, P_numtype2 > > >
+operator!=(double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double != _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<double, typename P_expr2::T_numtype > > >
+operator!=(double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double != VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<double, P_numtype2 > > >
+operator!=(double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// double != Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range,
+      _bz_NotEqual<double, int > > >
+operator!=(double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      Range, 
+      _bz_NotEqual<double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2));
+}
+
+// double != TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<double, P_numtype2 > > >
+operator!=(double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), 
+      d2.beginFast()));
+}
+
+// long double != Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<long double, P_numtype2 > > >
+operator!=(long double d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double != _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<long double, typename P_expr2::T_numtype > > >
+operator!=(long double d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<long double, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double != VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<long double, P_numtype2 > > >
+operator!=(long double d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+
+// long double != Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range,
+      _bz_NotEqual<long double, int > > >
+operator!=(long double d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      Range, 
+      _bz_NotEqual<long double, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2));
+}
+
+// long double != TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<long double, P_numtype2 > > >
+operator!=(long double d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<long double, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), 
+      d2.beginFast()));
+}
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != Vector<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>,
+      _bz_NotEqual<complex<T1> , P_numtype2 > > >
+operator!=(complex<T1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorIterConst<P_numtype2>, 
+      _bz_NotEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != _bz_VecExpr<P_expr2>
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>,
+      _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype > > >
+operator!=(complex<T1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      _bz_VecExpr<P_expr2>, 
+      _bz_NotEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != VectorPick<P_numtype2>
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>,
+      _bz_NotEqual<complex<T1> , P_numtype2 > > >
+operator!=(complex<T1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_NotEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != Range
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range,
+      _bz_NotEqual<complex<T1> , int > > >
+operator!=(complex<T1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      Range, 
+      _bz_NotEqual<complex<T1> , int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2));
+}
+#endif // BZ_HAVE_COMPLEX
+
+#ifdef BZ_HAVE_COMPLEX
+
+// complex<T1> != TinyVector<P_numtype2, N_length2>
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_NotEqual<complex<T1> , P_numtype2 > > >
+operator!=(complex<T1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_NotEqual<complex<T1> , P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), 
+      d2.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+/****************************************************************************
+ * Logical AND operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> && Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> && _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> && VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> && Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> && TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> && int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> && Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> && _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> && VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> && Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> && TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> && int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int > > >
+operator&&(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalAnd<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> && Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> && _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> && VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> && Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> && TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> && int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range && Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range && _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype > > >
+operator&&(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range && VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range && Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_LogicalAnd<int, int > > >
+operator&&(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_LogicalAnd<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range && TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> && Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> && _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> && VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> && Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> && TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<P_numtype1, P_numtype2 > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> && int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalAnd<P_numtype1, int > > >
+operator&&(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalAnd<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int && Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int && _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype > > >
+operator&&(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalAnd<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int && VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int && TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalAnd<int, P_numtype2 > > >
+operator&&(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalAnd<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+/****************************************************************************
+ * Logical OR operators
+ ****************************************************************************/
+
+// Vector<P_numtype1> || Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> || _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator||(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> || VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> || Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const Vector<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// Vector<P_numtype1> || TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// Vector<P_numtype1> || int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const Vector<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// _bz_VecExpr<P_expr1> || Vector<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> || _bz_VecExpr<P_expr2>
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> || VectorPick<P_numtype2>
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> || Range
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range,
+      _bz_LogicalOr<typename P_expr1::T_numtype, int > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// _bz_VecExpr<P_expr1> || TinyVector<P_numtype2, N_length2>
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// _bz_VecExpr<P_expr1> || int
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalOr<typename P_expr1::T_numtype, int > > >
+operator||(_bz_VecExpr<P_expr1> d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalOr<typename P_expr1::T_numtype, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// VectorPick<P_numtype1> || Vector<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> || _bz_VecExpr<P_expr2>
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> || VectorPick<P_numtype2>
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> || Range
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// VectorPick<P_numtype1> || TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// VectorPick<P_numtype1> || int
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const VectorPick<P_numtype1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// Range || Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(Range d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range || _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<int, typename P_expr2::T_numtype > > >
+operator||(Range d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range || VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(Range d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// Range || Range
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      Range,
+      _bz_LogicalOr<int, int > > >
+operator||(Range d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      Range, 
+      _bz_LogicalOr<int, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2));
+}
+
+// Range || TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> || Vector<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> || _bz_VecExpr<P_expr2>
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> || VectorPick<P_numtype2>
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> || Range
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2));
+}
+
+// TinyVector<P_numtype1, N_length1> || TinyVector<P_numtype2, N_length2>
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<P_numtype1, P_numtype2 > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast()));
+}
+
+// TinyVector<P_numtype1, N_length1> || int
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>,
+      _bz_LogicalOr<P_numtype1, int > > >
+operator||(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_LogicalOr<P_numtype1, int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2)));
+}
+
+// int || Vector<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(int d1, 
+      const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int || _bz_VecExpr<P_expr2>
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>,
+      _bz_LogicalOr<int, typename P_expr2::T_numtype > > >
+operator||(int d1, 
+      _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_LogicalOr<int, typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2));
+}
+
+// int || VectorPick<P_numtype2>
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(int d1, 
+      const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+
+// int || TinyVector<P_numtype2, N_length2>
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>,
+      _bz_LogicalOr<int, P_numtype2 > > >
+operator||(int d1, 
+      const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_LogicalOr<int, P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), 
+      d2.beginFast()));
+}
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/veccount.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/veccount.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/veccount.cc	(revision 73)
@@ -0,0 +1,67 @@
+/*
+ * $Id: veccount.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECCOUNT_CC
+#define BZ_VECCOUNT_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/veccount.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline int _bz_vec_count(P_expr vector)
+{
+    int length = vector._bz_suggestLength();
+    int count = 0;
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            if (vector._bz_fastAccess(i))
+                ++count;
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            if (vector[i])
+                ++count;
+    }
+
+    return count;
+}
+
+template<typename P_numtype>
+inline int count(const Vector<P_numtype>& x)
+{
+    return _bz_vec_count(x._bz_asVecExpr());
+}
+
+template<typename P_expr>
+inline int count(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_count(expr);
+}
+
+template<typename P_numtype>
+inline int count(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_count(x._bz_asVecExpr());
+}
+
+template<typename P_numtype, int N_dimensions>
+inline int count(const TinyVector<P_numtype, N_dimensions>& x)
+{
+    return _bz_vec_count(x._bz_asVecExpr());
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECCOUNT_CC
+
Index: /XMLIO_V2/external/include/blitz/vecdelta.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecdelta.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecdelta.cc	(revision 73)
@@ -0,0 +1,75 @@
+/*
+ * $Id: vecdelta.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECDELTA_CC
+#define BZ_VECDELTA_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecdelta.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P>
+inline
+Vector<BZ_DIFFTYPE(_bz_typename P::T_numtype)> _bz_vec_delta(P expr)
+{
+    typedef _bz_typename P::T_numtype   T_numtype;
+    typedef BZ_DIFFTYPE(T_numtype)      T_difftype;
+
+    int length = expr._bz_suggestLength();
+    Vector<T_difftype> z(length);
+    T_numtype currentElement = 0;
+    T_numtype previousElement = 0;
+
+    if (expr._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+        {
+            currentElement = expr._bz_fastAccess(i);
+            z[i] = currentElement - previousElement;
+            previousElement = currentElement;
+        }
+    }
+    else {
+        for (int i=1; i < length; ++i)
+        {
+            currentElement = expr(i);
+            z[i] = currentElement - previousElement;
+            previousElement = currentElement;
+        }
+    }
+
+    return z;
+}
+
+template<typename P_numtype>
+Vector<BZ_DIFFTYPE(P_numtype)> delta(const Vector<P_numtype>& x)
+{
+    return _bz_vec_delta(x);
+}
+
+// delta(expr)
+template<typename P_expr>
+Vector<BZ_DIFFTYPE(_bz_typename P_expr::T_numtype)> delta(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_delta(x);
+}
+
+// delta(vecpick)
+template<typename P_numtype>
+Vector<BZ_DIFFTYPE(P_numtype)> delta(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_delta(x);
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECDELTA_CC
+
Index: /XMLIO_V2/external/include/blitz/vecdot.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecdot.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecdot.cc	(revision 73)
@@ -0,0 +1,132 @@
+/*
+ * $Id: vecdot.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECDOT_CC
+#define BZ_VECDOT_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecdot.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P1, typename P2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(_bz_typename P1::T_numtype, _bz_typename P2::T_numtype))
+_bz_dot(P1 vector1, P2 vector2)
+{
+    BZPRECONDITION(vector1._bz_suggestLength() == vector2._bz_suggestLength());
+
+    typedef BZ_SUMTYPE(BZ_PROMOTE(_bz_typename P1::T_numtype,
+        _bz_typename P2::T_numtype))  T_sumtype;
+
+    T_sumtype sum = 0;
+    int length = vector1._bz_suggestLength();
+
+    if (vector1._bz_hasFastAccess() && vector2._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            sum += vector1._bz_fastAccess(i) 
+                * vector2._bz_fastAccess(i);
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            sum += vector1[i] * vector2[i];
+    }
+
+    return sum;
+}
+
+
+// dot()
+template<typename P_numtype1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1,P_numtype2))
+dot(const Vector<P_numtype1>& a, const Vector<P_numtype2>& b)
+{
+    return _bz_dot(a, b);
+}
+
+// dot(expr,expr)
+template<typename P_expr1, typename P_expr2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(_bz_typename P_expr1::T_numtype,
+    _bz_typename P_expr2::T_numtype))
+dot(_bz_VecExpr<P_expr1> expr1, _bz_VecExpr<P_expr2> expr2)
+{
+    return _bz_dot(expr1, expr2);
+}
+
+// dot(expr,vec)
+template<typename P_expr1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(_bz_typename P_expr1::T_numtype, P_numtype2))
+dot(_bz_VecExpr<P_expr1> expr1, const Vector<P_numtype2>& vector2)
+{
+    return _bz_dot(vector2, expr1);
+}
+
+// dot(vec,expr)
+template<typename P_numtype1, typename P_expr2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1, _bz_typename P_expr2::T_numtype))
+dot(const Vector<P_numtype1>& vector1, _bz_VecExpr<P_expr2> expr2)
+{
+    return _bz_dot(vector1, expr2);
+}
+
+// dot(vec,vecpick)
+template<typename P_numtype1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1, P_numtype2))
+dot(const Vector<P_numtype1>& vector1, const VectorPick<P_numtype2>& vector2)
+{
+    return _bz_dot(vector1, vector2);
+}
+
+// dot(vecpick,vec)
+template<typename P_numtype1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1, P_numtype2))
+dot(const VectorPick<P_numtype1>& vector1, const Vector<P_numtype2>& vector2)
+{
+    return _bz_dot(vector1, vector2);
+}
+
+// dot(vecpick,vecpick)
+template<typename P_numtype1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1, P_numtype2))
+dot(const VectorPick<P_numtype1>& vector1, const VectorPick<P_numtype2>& vector2)
+{
+    return _bz_dot(vector1, vector2);
+}
+
+// dot(expr, vecpick)
+template<typename P_expr1, typename P_numtype2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(_bz_typename P_expr1::T_numtype, P_numtype2))
+dot(_bz_VecExpr<P_expr1> expr1, const VectorPick<P_numtype2>& vector2)
+{
+    return _bz_dot(expr1, vector2);
+}
+
+// dot(vecpick, expr)
+template<typename P_numtype1, typename P_expr2>
+inline
+BZ_SUMTYPE(BZ_PROMOTE(P_numtype1, _bz_typename P_expr2::T_numtype))
+dot(const VectorPick<P_numtype1>& vector1, _bz_VecExpr<P_expr2> expr2)
+{
+    return _bz_dot(vector1, expr2);
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECDOT_CC
+
Index: /XMLIO_V2/external/include/blitz/vecexpr.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecexpr.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecexpr.h	(revision 73)
@@ -0,0 +1,282 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/vecexpr.h      Vector<P_numtype> expression templates
+ *
+ * $Id: vecexpr.h,v 1.11 2005/10/06 23:30:51 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_VECEXPR_H
+#define BZ_VECEXPR_H
+
+#include <blitz/vector.h>
+#include <blitz/applics.h>
+#include <blitz/meta/metaprog.h>
+#include <blitz/vecexprwrap.h>           // _bz_VecExpr wrapper class
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr1, typename P_expr2, typename P_op>
+class _bz_VecExprOp {
+
+public:
+    typedef P_expr1 T_expr1;
+    typedef P_expr2 T_expr2;
+    typedef _bz_typename T_expr1::T_numtype T_numtype1;
+    typedef _bz_typename T_expr2::T_numtype T_numtype2;
+    typedef BZ_PROMOTE(T_numtype1, T_numtype2) T_numtype;
+    typedef P_op    T_op;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_VecExprOp(T_expr1 a, T_expr2 b)
+        : iter1_(a), iter2_(b)
+    { }
+#else
+    _bz_VecExprOp(const T_expr1& a, const T_expr2& b)
+        : iter1_(a), iter2_(b)
+    { }
+#endif
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecExprOp(const _bz_VecExprOp<P_expr1, P_expr2, P_op>& x)
+        : iter1_(x.iter1_), iter2_(x.iter2_)
+    { }
+#endif
+
+    T_numtype operator[](int i) const
+    { return T_op::apply(iter1_[i], iter2_[i]); }
+
+    T_numtype operator()(int i) const
+    { return T_op::apply(iter1_(i), iter2_(i)); }
+
+    int length(int recommendedLength) const
+    { 
+        BZPRECONDITION(iter2_.length(recommendedLength) == 
+            iter1_.length(recommendedLength));
+        return iter1_.length(recommendedLength); 
+    }
+
+    static const int 
+        _bz_staticLengthCount = P_expr1::_bz_staticLengthCount
+                              + P_expr2::_bz_staticLengthCount,
+        _bz_dynamicLengthCount = P_expr1::_bz_dynamicLengthCount
+                               + P_expr2::_bz_dynamicLengthCount,
+        _bz_staticLength =
+            (P_expr1::_bz_staticLength > P_expr2::_bz_staticLength) ?
+            P_expr1::_bz_staticLength : P_expr2::_bz_staticLength;
+
+//      _bz_meta_max<P_expr1::_bz_staticLength, P_expr2::_bz_staticLength>::max 
+
+    int _bz_suggestLength() const
+    {
+        int length1 = iter1_._bz_suggestLength();
+        if (length1 != 0)
+            return length1;
+        return iter2_._bz_suggestLength();
+    }
+
+    bool _bz_hasFastAccess() const
+    { return iter1_._bz_hasFastAccess() && iter2_._bz_hasFastAccess(); }
+
+    T_numtype _bz_fastAccess(int i) const
+    { 
+        return T_op::apply(iter1_._bz_fastAccess(i),
+            iter2_._bz_fastAccess(i)); 
+    }
+    
+private:
+    _bz_VecExprOp();
+
+    T_expr1 iter1_;
+    T_expr2 iter2_;
+};
+
+template<typename P_expr, typename P_unaryOp>
+class _bz_VecExprUnaryOp {
+
+public:
+    typedef P_expr T_expr;
+    typedef P_unaryOp T_unaryOp;
+    typedef _bz_typename T_unaryOp::T_numtype T_numtype;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_VecExprUnaryOp(T_expr iter)
+        : iter_(iter)
+    { }
+#else
+    _bz_VecExprUnaryOp(const T_expr& iter)
+        : iter_(iter)
+    { }
+#endif
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecExprUnaryOp(const _bz_VecExprUnaryOp<P_expr, P_unaryOp>& x)
+        : iter_(x.iter_)
+    { }
+#endif
+
+    T_numtype operator[](int i) const
+    { return T_unaryOp::apply(iter_[i]); }
+
+    T_numtype operator()(int i) const
+    { return T_unaryOp::apply(iter_(i)); }
+
+    int length(int recommendedLength) const
+    { return iter_.length(recommendedLength); }
+
+    static const int
+        _bz_staticLengthCount = P_expr::_bz_staticLengthCount,
+        _bz_dynamicLengthCount = P_expr::_bz_dynamicLengthCount,
+        _bz_staticLength = P_expr::_bz_staticLength;
+
+    int _bz_suggestLength() const
+    { return iter_._bz_suggestLength(); }
+
+    bool _bz_hasFastAccess() const
+    { return iter_._bz_hasFastAccess(); }
+
+    T_numtype _bz_fastAccess(int i) const
+    { return T_unaryOp::apply(iter_._bz_fastAccess(i)); }
+
+private:
+    _bz_VecExprUnaryOp() { }
+
+    T_expr iter_;    
+};
+
+template<typename P_numtype>
+class _bz_VecExprConstant {
+public:
+    typedef P_numtype T_numtype;
+
+    _bz_VecExprConstant(P_numtype value)
+        : value_(BZ_NO_PROPAGATE(value))
+    { 
+    }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecExprConstant(const _bz_VecExprConstant<P_numtype>& x)
+        : value_(x.value_)
+    { }
+#endif
+
+    T_numtype operator[](int) const
+    { return value_; }
+
+    T_numtype operator()(int) const
+    { return value_; }
+
+    int length(int recommendedLength) const
+    { return recommendedLength; }
+
+    static const int
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 0,
+        _bz_staticLength = 0;
+
+    int _bz_suggestLength() const
+    { return 0; }
+
+    bool _bz_hasFastAccess() const
+    { return 1; }
+
+    T_numtype _bz_fastAccess(int) const
+    { return value_; }
+
+private:
+
+    _bz_VecExprConstant() { }
+
+    T_numtype value_;
+};
+
+BZ_NAMESPACE_END
+
+
+#ifndef BZ_TINYVEC_H
+ #include <blitz/tinyvec.h>
+#endif
+
+
+BZ_NAMESPACE(blitz)
+
+// Some miscellaneous operators that don't seem to belong anywhere else.
+
+template<typename P_expr>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr>, 
+    _bz_negate<_bz_typename P_expr::T_numtype> > >
+operator-(_bz_VecExpr<P_expr> a)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr>,
+        _bz_negate<_bz_typename P_expr::T_numtype> > T_expr;
+    return _bz_VecExpr<T_expr>(T_expr(a));
+}
+
+template<typename P_numtype>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype>,
+    _bz_negate<P_numtype> > >
+operator-(const Vector<P_numtype>& a)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype>,
+        _bz_negate<P_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(a.beginFast()));
+}
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range, _bz_negate<Range::T_numtype> > >
+operator-(Range r)
+{
+    typedef _bz_VecExprUnaryOp<Range, _bz_negate<Range::T_numtype> > T_expr;
+    
+    return _bz_VecExpr<T_expr>(T_expr(r));
+}
+
+template<typename P_numtype>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype>,
+    _bz_negate<P_numtype> > >
+operator-(const VectorPick<P_numtype>& a)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype>,
+        _bz_negate<P_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(a.beginFast()));
+}
+
+template<typename P_numtype, int N_length>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype,N_length>,
+    _bz_negate<P_numtype> > >
+operator-(const TinyVector<P_numtype,N_length>& a)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype,N_length>,
+        _bz_negate<P_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(a.beginFast()));
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECEXPR_H
Index: /XMLIO_V2/external/include/blitz/vecexprwrap.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecexprwrap.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecexprwrap.h	(revision 73)
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/vecexprwrap.h   Vector expression templates wrapper class
+ *
+ * $Id: vecexprwrap.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_VECEXPRWRAP_H
+#define BZ_VECEXPRWRAP_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+class _bz_VecExpr {
+
+public:
+    typedef P_expr T_expr;
+    typedef _bz_typename T_expr::T_numtype T_numtype;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_VecExpr(T_expr a)
+        : iter_(a)
+    { }
+#else
+    _bz_VecExpr(const T_expr& a)
+        : iter_(a)
+    { }
+#endif
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecExpr(const _bz_VecExpr<T_expr>& a)
+        : iter_(a.iter_)
+    { }
+#endif
+
+    T_numtype operator[](int i) const
+    { return iter_[i]; }
+
+    T_numtype operator()(int i) const
+    { return iter_(i); }
+
+    int length(int recommendedLength) const
+    { return iter_.length(recommendedLength); }
+
+    static const int 
+        _bz_staticLengthCount = P_expr::_bz_staticLengthCount,
+        _bz_dynamicLengthCount = P_expr::_bz_dynamicLengthCount,
+        _bz_staticLength = P_expr::_bz_staticLength;
+
+    int _bz_suggestLength() const
+    { return iter_._bz_suggestLength(); }
+
+    bool _bz_hasFastAccess() const
+    { return iter_._bz_hasFastAccess(); }
+
+    T_numtype _bz_fastAccess(int i) const
+    { return iter_._bz_fastAccess(i); }
+
+private:
+    _bz_VecExpr();
+
+    T_expr iter_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECEXPRWRAP_H
Index: /XMLIO_V2/external/include/blitz/vecglobs.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecglobs.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecglobs.cc	(revision 73)
@@ -0,0 +1,29 @@
+/*
+ * $Id: vecglobs.cc,v 1.2 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECGLOBS_CC
+#define BZ_VECGLOBS_CC
+
+#ifndef BZ_VECGLOBS_H
+ #include <blitz/vecglobs.h>
+#endif
+
+#include <blitz/vecaccum.cc>    // accumulate()
+#include <blitz/vecdelta.cc>    // delta()
+#include <blitz/vecmin.cc>      // min(), minValue(), minIndex()
+#include <blitz/vecmax.cc>      // max(), maxValue(), maxIndex()
+#include <blitz/vecsum.cc>      // sum(), mean()
+#include <blitz/vecdot.cc>      // dot()
+#include <blitz/vecnorm.cc>     // norm()
+#include <blitz/vecnorm1.cc>    // norm1()
+#include <blitz/vecany.cc>      // any()
+#include <blitz/vecall.cc>      // all()
+#include <blitz/veccount.cc>    // count()
+
+#endif // BZ_VECGLOBS_CC
Index: /XMLIO_V2/external/include/blitz/vecglobs.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecglobs.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecglobs.h	(revision 73)
@@ -0,0 +1,52 @@
+/***************************************************************************
+ * blitz/vecglobs.h      Global vector functions
+ *
+ * $Id: vecglobs.h,v 1.3 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_VECGLOBS_H
+#define BZ_VECGLOBS_H
+
+#ifndef BZ_VECTOR_H
+ #include <blitz/vector.h>
+#endif
+
+#ifndef BZ_NUMTRAIT_H
+ #include <blitz/numtrait.h>
+#endif
+
+#ifndef BZ_PROMOTE_H
+ #include <blitz/promote.h>
+#endif
+
+#ifndef BZ_EXTREMUM_H
+ #include <blitz/extremum.h>
+#endif
+
+
+BZ_NAMESPACE(blitz)
+
+BZ_NAMESPACE_END
+
+#include <blitz/vecglobs.cc>
+
+#endif // BZ_VECGLOBS_H
Index: /XMLIO_V2/external/include/blitz/vecio.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecio.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecio.cc	(revision 73)
@@ -0,0 +1,47 @@
+/*
+ * $Id: vecio.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECIO_CC
+#define BZ_VECIO_CC
+
+#ifndef BZ_VECTOR_H
+ #include <blitz/vector.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// This version of operator<< is provided as a temporary measure
+// only.  It will be revised in a future release.
+// NEEDS_WORK
+
+template<typename P_numtype>
+ostream& operator<<(ostream& os, const Vector<P_numtype>& x)
+{
+    os << "[ ";
+    for (int i=0; i < x.length(); ++i)
+    {
+        os << setw(10) << x[i];
+        if (!((i+1)%7))
+            os << endl << "  ";
+    }
+    os << " ]";
+    return os;
+}
+
+template<typename P_expr>
+ostream& operator<<(ostream& os, _bz_VecExpr<P_expr> expr)
+{
+    Vector<_bz_typename P_expr::T_numtype> result(expr);
+    os << result;
+    return os;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECIO_CC
Index: /XMLIO_V2/external/include/blitz/veciter.h
===================================================================
--- /XMLIO_V2/external/include/blitz/veciter.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/veciter.h	(revision 73)
@@ -0,0 +1,205 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/veciter.h      Iterator classes for Vector<P_numtype>
+ *
+ * $Id: veciter.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+
+#ifndef BZ_VECITER_H
+#define BZ_VECITER_H
+
+#ifndef BZ_VECTOR_H
+ #error <blitz/veciter.h> should be included via <blitz/vector.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+// Declaration of class VectorIter
+template<typename P_numtype>
+class VectorIter {
+public:
+    typedef P_numtype T_numtype;
+
+    explicit VectorIter(Vector<P_numtype>& x)
+        : data_(x.data())
+    {
+        stride_ = x.stride();
+        length_ = x.length();
+    }
+
+    VectorIter(P_numtype* restrict data, int stride, int length)
+        : data_(data), stride_(stride), length_(length)
+    { }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    VectorIter(const VectorIter<P_numtype>& x)
+    {
+        data_ = x.data_;
+        stride_ = x.stride_;
+        length_ = x.length_;
+    }
+#endif
+
+    P_numtype operator[](int i) const
+    { 
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_]; 
+    }
+
+    P_numtype& restrict operator[](int i)
+    { 
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_]; 
+    }
+
+    P_numtype operator()(int i) const
+    {
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_];
+    }
+
+    P_numtype& restrict operator()(int i) 
+    {
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_];
+    }
+
+    P_numtype operator*() const
+    { return *data_; }
+
+    P_numtype& operator*()
+    { return *data_; }
+
+    VectorIter<P_numtype> operator+(int i)
+    {
+        // NEEDS_WORK -- precondition checking?
+        return VectorIter<P_numtype>(data_+i*stride_, stride_, length_-i);
+    }
+
+    int length(int) const
+    { return length_; }
+
+    bool isUnitStride() const
+    { return (stride_ == 1); }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    static const int 
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 1,
+        _bz_staticLength = 0;
+
+    bool _bz_hasFastAccess() const
+    { return isUnitStride(); }
+
+    P_numtype _bz_fastAccess(int i) const
+    { return data_[i]; }
+
+    P_numtype& restrict _bz_fastAccess(int i)
+    { return data_[i]; }
+
+    int _bz_suggestLength() const
+    { return length_; }
+
+private:
+    VectorIter() { }
+    P_numtype * restrict data_;
+    int stride_;
+    int length_;
+};
+
+
+template<typename P_numtype>
+class VectorIterConst {
+public:
+    typedef P_numtype T_numtype;
+
+    explicit VectorIterConst(const Vector<P_numtype>& x)
+        : data_(x.data())
+    {
+        stride_ = x.stride();
+        length_ = x.length();
+    }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    VectorIterConst(const VectorIterConst<P_numtype>& x)
+    {
+        data_ = x.data_;
+        stride_ = x.stride_;
+        length_ = x.length_;
+    }
+#endif
+
+    P_numtype operator[](int i) const
+    { 
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_]; 
+    }
+
+    P_numtype operator()(int i) const
+    {
+        BZPRECONDITION(i < length_);
+        return data_[i*stride_];
+    }
+
+    int length(int) const
+    { return length_; }
+
+    bool isUnitStride() const
+    { return (stride_ == 1); }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    static const int 
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 1,
+        _bz_staticLength = 0;
+
+    bool  _bz_hasFastAccess() const
+    { return isUnitStride(); }
+
+    P_numtype _bz_fastAccess(int i) const
+    {
+        return data_[i];
+    }
+
+    int _bz_suggestLength() const
+    { return length_; }
+
+private:
+    const P_numtype * restrict data_;
+    int stride_;
+    int length_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECITER_H
Index: /XMLIO_V2/external/include/blitz/vecmax.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecmax.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecmax.cc	(revision 73)
@@ -0,0 +1,152 @@
+/*
+ * $Id: vecmax.cc,v 1.4 2005/06/02 18:56:52 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECMAX_CC
+#define BZ_VECMAX_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecmax.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline
+Extremum<_bz_typename P_expr::T_numtype, int> _bz_vec_max(P_expr vector)
+{
+    typedef _bz_typename P_expr::T_numtype T_numtype;
+
+    T_numtype maxValue = vector(0);
+    int maxIndex = 0;
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=1; i < length; ++i)
+        {
+            T_numtype value = vector._bz_fastAccess(i);
+            if (value > maxValue)
+            {
+                maxValue = value;
+                maxIndex = i;
+            }
+        }
+    }
+    else {
+        for (int i=1; i < length; ++i)
+        {
+            T_numtype value = vector(i);
+            if (value > maxValue)
+            {
+                maxValue = value;
+                maxIndex = i;
+            }
+        }
+    }
+
+    return Extremum<T_numtype, int>(maxValue, maxIndex);
+}
+
+// max(vector)
+template<typename P_numtype>
+inline
+Extremum<P_numtype, int> (max)(const Vector<P_numtype>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr());
+}
+
+// max(expr)
+template<typename P_expr>
+inline
+Extremum<_bz_typename P_expr::T_numtype,int> (max)(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_max(x);
+}
+
+// max(vecpick)
+template<typename P_numtype>
+inline
+Extremum<P_numtype, int> (max)(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr());
+}
+
+// max(TinyVector)
+template<typename P_numtype, int N_length>
+inline
+Extremum<P_numtype, int> (max)(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr());
+}
+
+
+// maxIndex(vector)
+template<typename P_numtype>
+inline
+int maxIndex(const Vector<P_numtype>& x)
+{
+    return _bz_vec_max(x).index();
+}
+
+// maxIndex(expr)
+template<typename P_expr>
+inline
+int maxIndex(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).index();
+}
+
+// maxIndex(vecpick)
+template<typename P_numtype>
+int maxIndex(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).index();
+}
+
+// maxIndex(TinyVector)
+template<typename P_numtype, int N_length>
+int maxIndex(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).index();
+}
+
+// maxValue(vector)
+template<typename P_numtype>
+inline
+int maxValue(const Vector<P_numtype>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).value();
+}
+
+// maxValue(expr)
+template<typename P_expr>
+inline
+int maxValue(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_max(x).value();
+}
+
+// maxValue(vecpick)
+template<typename P_numtype>
+int maxValue(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).value();
+}
+
+// maxValue(TinyVector)
+template<typename P_numtype, int N_length>
+int maxValue(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_max(x._bz_asVecExpr()).value();
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECMAX_CC
+
Index: /XMLIO_V2/external/include/blitz/vecmin.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecmin.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecmin.cc	(revision 73)
@@ -0,0 +1,151 @@
+/*
+ * $Id: vecmin.cc,v 1.4 2005/06/02 18:56:08 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECMIN_CC
+#define BZ_VECMIN_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecmin.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline
+Extremum<_bz_typename P_expr::T_numtype, int> _bz_vec_min(P_expr vector)
+{
+    typedef _bz_typename P_expr::T_numtype T_numtype;
+
+    T_numtype minValue = vector(0);
+    int minIndex = 0;
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=1; i < length; ++i)
+        {
+            T_numtype value = vector._bz_fastAccess(i);
+            if (value < minValue)
+            {
+                minValue = value;
+                minIndex = i;
+            }
+        }
+    }
+    else {
+        for (int i=1; i < length; ++i)
+        {
+            T_numtype value = vector(i);
+            if (value < minValue)
+            {
+                minValue = value;
+                minIndex = i;
+            }
+        }
+    }
+
+    return Extremum<T_numtype, int>(minValue, minIndex);
+}
+
+// min(vector)
+template<typename P_numtype>
+inline
+Extremum<P_numtype,int> (min)(const Vector<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr());
+}
+
+// min(expr)
+template<typename P_expr>
+inline
+Extremum<_bz_typename P_expr::T_numtype,int> (min)(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_min(x);
+}
+
+// min(vecpick)
+template<typename P_numtype>
+inline
+Extremum<P_numtype, int> (min)(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr());
+}
+
+// min(TinyVector)
+template<typename P_numtype, int N_length>
+inline
+Extremum<P_numtype, int> (min)(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr());
+}
+
+// minIndex(vector)
+template<typename P_numtype>
+inline
+int minIndex(const Vector<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).index();
+}
+
+// maxIndex(expr)
+template<typename P_expr>
+inline
+int minIndex(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_min(x).index();
+}
+
+// minIndex(vecpick)
+template<typename P_numtype>
+int minIndex(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).index();
+}
+
+// minIndex(TinyVector)
+template<typename P_numtype, int N_length>
+int minIndex(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).index();
+}
+
+// minValue(vector)
+template<typename P_numtype>
+inline
+int minValue(const Vector<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).value();
+}
+
+// minValue(expr)
+template<typename P_expr>
+inline
+int minValue(_bz_VecExpr<P_expr> x)
+{
+    return _bz_vec_min(x).value();
+}
+
+// minValue(vecpick)
+template<typename P_numtype>
+int minValue(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).value();
+}
+
+// minValue(TinyVector)
+template<typename P_numtype, int N_length>
+int minValue(const TinyVector<P_numtype, N_length>& x)
+{
+    return _bz_vec_min(x._bz_asVecExpr()).value();
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECMIN_CC
+
Index: /XMLIO_V2/external/include/blitz/vecnorm.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecnorm.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecnorm.cc	(revision 73)
@@ -0,0 +1,92 @@
+/*
+ * $Id: vecnorm.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECNORM_CC
+#define BZ_VECNORM_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecnorm.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(_bz_typename P_expr::T_numtype))
+_bz_vec_norm(P_expr vector)
+{
+    // An extreme use of traits here.  It's necessary to
+    // handle odd cases such as the norm of a Vector<char>.
+    // To avoid overflow, BZ_SUMTYPE(char) is int.
+    // To take the sqrt of the sum, BZ_FLOATTYPE(char) is float.
+    // So float is returned for Vector<char>.
+    typedef _bz_typename P_expr::T_numtype T_numtype;
+    typedef BZ_SUMTYPE(T_numtype)          T_sumtype;
+    typedef BZ_FLOATTYPE(T_sumtype)        T_floattype;
+
+    T_sumtype sum = 0;
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+        {
+            T_numtype value = vector._bz_fastAccess(i);
+            sum += value * T_sumtype(value);
+        }
+    }
+    else {
+        for (int i=0; i < length; ++i)
+        {
+            T_numtype value = vector(i);
+            sum += value * T_sumtype(value);
+        }
+    }
+
+    return _bz_sqrt<T_floattype>::apply(sum);
+}
+
+template<typename P_numtype>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype)) norm(const Vector<P_numtype>& x)
+{
+    return _bz_vec_norm(x._bz_asVecExpr());
+}
+
+// norm(expr)
+template<typename P_expr>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(_bz_typename P_expr::T_numtype))
+norm(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_norm(expr);
+}
+
+// norm(vecpick)
+template<typename P_numtype>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype))
+norm(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_norm(x._bz_asVecExpr());
+}
+
+// norm(TinyVector)
+template<typename P_numtype, int N_dimensions>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype))
+norm(const TinyVector<P_numtype, N_dimensions>& x)
+{
+    return _bz_vec_norm(x._bz_asVecExpr());
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECNORM_CC
+
Index: /XMLIO_V2/external/include/blitz/vecnorm1.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecnorm1.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecnorm1.cc	(revision 73)
@@ -0,0 +1,77 @@
+/*
+ * $Id: vecnorm1.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECNORM1_CC
+#define BZ_VECNORM1_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecnorm1.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+#include <blitz/applics.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline
+BZ_SUMTYPE(_bz_typename P_expr::T_numtype)
+_bz_vec_norm1(P_expr vector)
+{
+    typedef _bz_typename P_expr::T_numtype T_numtype;
+    typedef BZ_SUMTYPE(T_numtype)          T_sumtype;
+
+    T_sumtype sum = 0;
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            sum += _bz_abs<T_numtype>::apply(vector._bz_fastAccess(i));
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            sum += _bz_abs<T_numtype>::apply(vector(i));
+    }
+
+    return sum;
+}
+
+// norm1(vector)
+template<typename P_numtype>
+BZ_SUMTYPE(P_numtype) norm1(const Vector<P_numtype>& x)
+{
+    return _bz_vec_norm1(x._bz_asVecExpr());
+}
+
+// norm1(expr)
+template<typename P_expr>
+BZ_SUMTYPE(_bz_typename P_expr::T_numtype) norm1(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_norm1(expr);
+}
+
+// norm1(vecpick)
+template<typename P_numtype>
+BZ_SUMTYPE(P_numtype) norm1(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_norm1(x._bz_asVecExpr());
+}
+
+// norm1(TinyVector)
+template<typename P_numtype, int N_dimensions>
+BZ_SUMTYPE(P_numtype) norm1(const TinyVector<P_numtype, N_dimensions>& x)
+{
+    return _bz_vec_norm1(x._bz_asVecExpr());
+}
+
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECNORM1_CC
+
Index: /XMLIO_V2/external/include/blitz/vecpick.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecpick.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecpick.cc	(revision 73)
@@ -0,0 +1,634 @@
+/*
+ * $Id: vecpick.cc,v 1.4 2005/10/06 23:29:34 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECPICK_CC
+#define BZ_VECPICK_CC
+
+#include <blitz/vecpick.h>
+#include <blitz/update.h>
+#include <blitz/random.h>
+#include <blitz/vecexpr.h>
+
+BZ_NAMESPACE(blitz)
+
+/*****************************************************************************
+ * Assignment operators with vector expression operand
+ */
+
+template<typename P_numtype> template<typename P_expr, typename P_updater>
+inline
+void VectorPick<P_numtype>::_bz_assign(P_expr expr, P_updater)
+{
+    BZPRECONDITION(expr.length(length()) == length());
+
+    // If all vectors in the expression, plus the vector to which the
+    // result is being assigned have unit stride, then avoid stride
+    // calculations.
+    if (_bz_hasFastAccess() && expr._bz_hasFastAccess())
+    {
+#ifndef BZ_PARTIAL_LOOP_UNROLL
+        for (int i=0; i < length(); ++i)
+            P_updater::update(vector_(index_(i)), expr._bz_fastAccess(i));
+#else
+        // Unwind the inner loop, five elements at a time.
+        int leftover = length() % 5;
+
+        int i=0;
+        for (; i < leftover; ++i)
+            P_updater::update(vector_(index_(i)), expr._bz_fastAccess(i));
+
+        for (; i < length(); i += 5)
+        {
+            P_updater::update(vector_(index_(i)), expr._bz_fastAccess(i));
+            P_updater::update(vector_(index_(i+1)), expr._bz_fastAccess(i+1));
+            P_updater::update(vector_(index_(i+2)), expr._bz_fastAccess(i+2));
+            P_updater::update(vector_(index_(i+3)), expr._bz_fastAccess(i+3));
+            P_updater::update(vector_(index_(i+4)), expr._bz_fastAccess(i+4));
+        }
+#endif
+    }
+    else {
+        // Not all unit strides -- have to access all the vector elements
+        // as data_[i*stride_], which is slower.
+        for (int i=0; i < length(); ++i)
+            P_updater::update(vector_[index_[i]], expr[i]);
+    }
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator=(_bz_VecExpr<P_expr> expr)
+{
+    BZPRECONDITION(expr.length(length()) == length());
+
+    // If all vectors in the expression, plus the vector to which the
+    // result is being assigned have unit stride, then avoid stride
+    // calculations.
+    if (_bz_hasFastAccess() && expr._bz_hasFastAccess())
+    {
+#ifndef BZ_PARTIAL_LOOP_UNROLL
+        for (int i=0; i < length(); ++i)
+            (*this)(i) = expr._bz_fastAccess(i);
+#else
+        // Unwind the inner loop, five elements at a time.
+        int leftover = length() % 5;
+
+        int i=0;
+        for (; i < leftover; ++i)
+            (*this)(i) = expr._bz_fastAccess(i);
+
+        for (; i < length(); i += 5)
+        {
+            (*this)(i) = expr._bz_fastAccess(i);
+            (*this)(i+1) = expr._bz_fastAccess(i+1);
+            (*this)(i+2) = expr._bz_fastAccess(i+2);
+            (*this)(i+3) = expr._bz_fastAccess(i+3);
+            (*this)(i+4) = expr._bz_fastAccess(i+4);
+        }
+#endif
+    }
+    else {
+        // Not all unit strides -- have to access all the vector elements
+        // as data_[i*stride_], which is slower.
+        for (int i=0; i < length(); ++i)
+            (*this)[i] = expr[i];
+    }
+    return *this;
+}
+
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator+=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_plus_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator-=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_minus_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator*=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_multiply_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator/=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_divide_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator%=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_mod_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator^=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_xor_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator&=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitand_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator|=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitor_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator>>=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftr_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator<<=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftl_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with scalar operand
+ */
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator+=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) += _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator-=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) -= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator*=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) *= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator/=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) /= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator%=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) %= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator^=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) ^= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator&=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) &= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator|=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) |= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator>>=(int x)
+{
+    typedef _bz_VecExprConstant<int> T_expr;
+    (*this) >>= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator<<=(int x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) <<= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with vector operand
+ */
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator=(const Vector<P_numtype2>& x)
+{
+    (*this) = _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator+=(const Vector<P_numtype2>& x)
+{
+    (*this) += _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator-=(const Vector<P_numtype2>& x)
+{
+    (*this) -= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator*=(const Vector<P_numtype2>& x)
+{
+    (*this) *= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator/=(const Vector<P_numtype2>& x)
+{
+    (*this) /= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator%=(const Vector<P_numtype2>& x)
+{
+    (*this) %= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator^=(const Vector<P_numtype2>& x)
+{
+    (*this) ^= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator&=(const Vector<P_numtype2>& x)
+{
+    (*this) &= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator|=(const Vector<P_numtype2>& x)
+{
+    (*this) |= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator<<=(const Vector<P_numtype2>& x)
+{
+    (*this) <<= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>&
+VectorPick<P_numtype>::operator>>=(const Vector<P_numtype2>& x)
+{
+    (*this) >>= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Range operand
+ */
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator=(Range r)
+{
+    (*this) = _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator+=(Range r)
+{
+    (*this) += _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator-=(Range r)
+{
+    (*this) -= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator*=(Range r)
+{
+    (*this) *= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator/=(Range r)
+{
+    (*this) /= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator%=(Range r)
+{
+    (*this) %= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator^=(Range r)
+{
+    (*this) ^= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator&=(Range r)
+{
+    (*this) &= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator|=(Range r)
+{
+    (*this) |= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator>>=(Range r)
+{
+    (*this) >>= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator<<=(Range r)
+{
+    (*this) <<= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with VectorPick operand
+ */
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator=(const 
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator+=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) += _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator-=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) -= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator*=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) *= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator/=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) /= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator%=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) %= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator^=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) ^= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator&=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) &= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline VectorPick<P_numtype>& VectorPick<P_numtype>::operator|=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) |= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Random operand
+ */
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator=(Random<P_distribution>& rand)
+{
+    (*this) = _bz_VecExpr<_bz_VecExprRandom<P_distribution> > 
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator+=(Random<P_distribution>& rand)
+{
+    (*this) += _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator-=(Random<P_distribution>& rand)
+{
+    (*this) -= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator*=(Random<P_distribution>& rand)
+{
+    (*this) *= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator/=(Random<P_distribution>& rand)
+{
+    (*this) /= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator%=(Random<P_distribution>& rand)
+{
+    (*this) %= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator^=(Random<P_distribution>& rand)
+{
+    (*this) ^= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator&=(Random<P_distribution>& rand)
+{
+    (*this) &= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+VectorPick<P_numtype>& 
+VectorPick<P_numtype>::operator|=(Random<P_distribution>& rand)
+{
+    (*this) |= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECPICK_CC
Index: /XMLIO_V2/external/include/blitz/vecpick.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecpick.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecpick.h	(revision 73)
@@ -0,0 +1,297 @@
+/***************************************************************************
+ * blitz/vecpick.h      Declaration of the VectorPick<T_numtype> class
+ *
+ * $Id: vecpick.h,v 1.5 2005/10/06 23:28:55 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_VECPICK_H
+#define BZ_VECPICK_H
+
+#include <blitz/vector.h>
+
+BZ_NAMESPACE(blitz)
+
+// Forward declarations
+
+template<typename P_numtype> class VectorPickIter;
+template<typename P_numtype> class VectorPickIterConst;
+
+// Declaration of class VectorPick<P_numtype>
+
+template<typename P_numtype>
+class VectorPick {
+
+public:
+    //////////////////////////////////////////////
+    // Public Types
+    //////////////////////////////////////////////
+
+    typedef P_numtype                      T_numtype;
+    typedef Vector<T_numtype>              T_vector;
+    typedef Vector<int>                    T_indexVector;
+    typedef VectorPick<T_numtype>          T_pick;
+    typedef VectorPickIter<T_numtype>      T_iterator;
+    typedef VectorPickIterConst<T_numtype> T_constIterator;
+
+    //////////////////////////////////////////////
+    // Constructors                             //
+    //////////////////////////////////////////////
+
+    VectorPick(T_vector& vector, T_indexVector& indexarg)
+        : vector_(vector), index_(indexarg)
+    { }
+
+    VectorPick(const T_pick& vecpick)
+        : vector_(const_cast<T_vector&>(vecpick.vector_)), 
+          index_(const_cast<T_indexVector&>(vecpick.index_))
+    { }
+
+    VectorPick(T_pick& vecpick, Range r)
+        : vector_(vecpick.vector_), index_(vecpick.index_[r])
+    { }
+ 
+    //////////////////////////////////////////////
+    // Member functions
+    //////////////////////////////////////////////
+
+    T_iterator         beginFast()
+    { return VectorPickIter<T_numtype>(*this); }
+
+    T_constIterator    beginFast()      const
+    { return VectorPickIterConst<T_numtype>(*this); }
+
+    // T_vector           copy()       const;
+
+    // T_iterator         end();
+
+    // T_constIterator    end()        const;
+
+    T_indexVector&     indexSet()
+    { return index_; }
+ 
+    const T_indexVector& indexSet()      const
+    { return index_; }
+
+    int           length()     const
+    { return index_.length(); }
+
+    void               setVector(Vector<T_numtype>& x)
+    { vector_.reference(x); }
+
+    void               setIndex(Vector<int>& index)
+    { index_.reference(index); }
+
+    T_vector&          vector()
+    { return vector_; }
+
+    const T_vector&    vector()     const
+    { return vector_; }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    int        _bz_suggestLength() const
+    { return index_.length(); }
+
+    bool        _bz_hasFastAccess() const
+    { return vector_._bz_hasFastAccess() && index_._bz_hasFastAccess(); }
+
+    T_numtype&      _bz_fastAccess(int i)
+    { return vector_._bz_fastAccess(index_._bz_fastAccess(i)); }
+
+    T_numtype       _bz_fastAccess(int i) const
+    { return vector_._bz_fastAccess(index_._bz_fastAccess(i)); }
+
+    _bz_VecExpr<T_constIterator> _bz_asVecExpr() const
+    { return _bz_VecExpr<T_constIterator>(beginFast()); }
+
+    //////////////////////////////////////////////
+    // Subscripting operators
+    //////////////////////////////////////////////
+
+    T_numtype       operator()(int i) const
+    { 
+        BZPRECONDITION(index_.stride() == 1);
+        BZPRECONDITION(vector_.stride() == 1);
+        BZPRECONDITION(i < index_.length());
+        BZPRECONDITION(index_[i] < vector_.length());
+        return vector_(index_(i));
+    }
+
+    T_numtype&      operator()(int i)
+    {
+        BZPRECONDITION(index_.stride() == 1);
+        BZPRECONDITION(vector_.stride() == 1);
+        BZPRECONDITION(i < index_.length());
+        BZPRECONDITION(index_[i] < vector_.length());
+        return vector_(index_(i));
+    }
+
+    T_numtype       operator[](int i) const
+    {
+        BZPRECONDITION(index_.stride() == 1);
+        BZPRECONDITION(vector_.stride() == 1);
+        BZPRECONDITION(i < index_.length());
+        BZPRECONDITION(index_[i] < vector_.length());
+        return vector_[index_[i]];
+    }
+
+    T_numtype&      operator[](int i)
+    {
+        BZPRECONDITION(index_.stride() == 1);
+        BZPRECONDITION(vector_.stride() == 1);
+        BZPRECONDITION(i < index_.length());
+        BZPRECONDITION(index_[i] < vector_.length());
+        return vector_[index_[i]];
+    }
+
+    T_pick          operator()(Range r)
+    {
+        return T_pick(*this, index_[r]);
+    }
+
+    T_pick          operator[](Range r)
+    {
+        return T_pick(*this, index_[r]);
+    }
+
+    //////////////////////////////////////////////
+    // Assignment operators
+    //////////////////////////////////////////////
+
+    // Scalar operand
+    T_pick& operator=(T_numtype);
+    T_pick& operator+=(T_numtype);
+    T_pick& operator-=(T_numtype);
+    T_pick& operator*=(T_numtype);
+    T_pick& operator/=(T_numtype);
+    T_pick& operator%=(T_numtype);
+    T_pick& operator^=(T_numtype);
+    T_pick& operator&=(T_numtype);
+    T_pick& operator|=(T_numtype);
+    T_pick& operator>>=(int);
+    T_pick& operator<<=(int);
+
+    // Vector operand
+    template<typename P_numtype2> T_pick& operator=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator+=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator-=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator*=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator/=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator%=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator^=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator&=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator|=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator>>=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_pick& operator<<=(const Vector<P_numtype2> &);
+
+    // Vector expression operand
+    template<typename P_expr> T_pick& operator=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator+=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator-=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator*=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator/=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator%=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator^=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator&=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator|=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator>>=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_pick& operator<<=(_bz_VecExpr<P_expr>);
+
+    // Range operand
+    T_pick& operator=(Range);
+    T_pick& operator+=(Range);
+    T_pick& operator-=(Range);
+    T_pick& operator*=(Range);
+    T_pick& operator/=(Range);
+    T_pick& operator%=(Range);
+    T_pick& operator^=(Range);
+    T_pick& operator&=(Range);
+    T_pick& operator|=(Range);
+    T_pick& operator>>=(Range);
+    T_pick& operator<<=(Range);
+
+    // Vector pick operand
+    template<typename P_numtype2> 
+    T_pick& operator=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator+=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator-=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator*=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator/=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator%=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator^=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator&=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator|=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator>>=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_pick& operator<<=(const VectorPick<P_numtype2> &);
+
+    // Random operand
+    template<typename P_distribution>
+    T_pick& operator=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator+=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator-=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator*=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator/=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator%=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator^=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator&=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_pick& operator|=(Random<P_distribution>& random);
+
+private:
+    VectorPick() { }
+
+    template<typename P_expr, typename P_updater>
+    inline void _bz_assign(P_expr, P_updater);
+
+private:
+    T_vector vector_;
+    T_indexVector index_;
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/vecpick.cc>
+#include <blitz/vecpickio.cc>
+#include <blitz/vecpickiter.h>
+
+#endif // BZ_VECPICK_H
Index: /XMLIO_V2/external/include/blitz/vecpickio.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecpickio.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecpickio.cc	(revision 73)
@@ -0,0 +1,30 @@
+/*
+ * $Id: vecpickio.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECPICKIO_CC
+#define BZ_VECPICKIO_CC
+
+#ifndef BZ_VECPICK_H
+ #error <blitz/vecpickio.cc> must be included via <blitz/vecpick.h>
+#endif // BZ_VECPICK_H
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype>
+ostream& operator<<(ostream& os, const VectorPick<P_numtype>& x)
+{
+    Vector<P_numtype> y(x.length());
+    y = x;
+    os << y;
+    return os;
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECPICKIO_CC
Index: /XMLIO_V2/external/include/blitz/vecpickiter.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecpickiter.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecpickiter.h	(revision 73)
@@ -0,0 +1,173 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/vecpickiter.h      Declaration of VectorPickIter<T_numtype> and
+ *                          VectorPickIterConst<T_numtype> classes
+ *
+ * $Id: vecpickiter.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_VECPICKITER_H
+#define BZ_VECPICKITER_H
+
+#ifndef BZ_VECPICK_H
+ #include <blitz/vecpick.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype>
+class VectorPickIter {
+
+public:
+    typedef P_numtype  T_numtype;
+
+    explicit VectorPickIter(VectorPick<T_numtype>& x)
+        : data_(x.vector().data()), index_(x.indexSet().data())
+    {
+        dataStride_  = x.vector().stride();
+        indexStride_ = x.indexSet().stride();
+        length_ = x.indexSet().length();
+    }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    VectorPickIter(const VectorPickIter<T_numtype>& x)
+    {
+        data_ = x.data_;
+        index_ = x.index_;
+        dataStride_ = x.dataStride_;
+        indexStride_ = x.indexStride_;
+        length_ = x.length_;
+    }
+#endif
+
+    T_numtype operator[](int i) const
+    {
+        BZPRECONDITION(i < length_);
+        return data_[dataStride_ * index_[i * indexStride_]];
+    }
+
+    T_numtype& operator[](int i)
+    {
+        BZPRECONDITION(i < length_);
+        return data_[dataStride_ * index_[i * indexStride_]];
+    }
+
+    int length(int) const
+    { return length_; }
+
+    int _bz_suggestLength() const
+    { return length_; }
+
+    bool isUnitStride() const
+    { return (dataStride_  == 1) && (indexStride_ == 1); }
+
+    bool _bz_hasFastAccess() const
+    { return isUnitStride(); }
+
+    T_numtype _bz_fastAccess(int i) const
+    {    
+         return data_[index_[i]];
+    }
+
+    T_numtype&  _bz_fastAccess(int i)
+    {
+         return data_[index_[i]];
+    }
+
+    static const int
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 1,
+        _bz_staticLength = 0;
+
+private:
+    T_numtype * restrict data_;
+    int dataStride_;
+    const int * restrict index_;
+    int indexStride_;
+    int length_;
+};
+
+template<typename P_numtype>
+class VectorPickIterConst {
+
+public:
+    typedef P_numtype  T_numtype;
+
+    explicit VectorPickIterConst(const VectorPick<T_numtype>& x)
+        : data_(x.vector().data()), index_(x.indexSet().data())
+    {
+        dataStride_  = x.vector().stride();
+        indexStride_ = x.indexSet().stride();
+        length_ = x.indexSet().length();
+    }
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    VectorPickIterConst(const VectorPickIterConst<T_numtype>& x)
+    {
+        data_ = x.data_;
+        index_ = x.index_;
+        dataStride_ = x.dataStride_;
+        indexStride_ = x.indexStride_;
+        length_ = x.length_;
+    }
+#endif
+
+    T_numtype operator[](int i) const
+    {
+        BZPRECONDITION(i < length_);
+        return data_[dataStride_ * index_[i * indexStride_]];
+    }
+
+    int length(int) const
+    { return length_; }
+
+    int _bz_suggestLength() const
+    { return length_; }
+
+    bool isUnitStride() const
+    { return (dataStride_  == 1) && (indexStride_ == 1); }
+
+    bool _bz_hasFastAccess() const
+    { return isUnitStride(); }
+
+    T_numtype _bz_fastAccess(int i) const
+    {
+         return data_[index_[i]];
+    }
+
+    static const int 
+        _bz_staticLengthCount = 0,
+        _bz_dynamicLengthCount = 1,
+        _bz_staticLength = 0;
+
+private:
+    const T_numtype * restrict data_;
+    int dataStride_;
+    const int * restrict index_;
+    int indexStride_;
+    int length_;
+};
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECPICKITER_H
+
Index: /XMLIO_V2/external/include/blitz/vecsum.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecsum.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecsum.cc	(revision 73)
@@ -0,0 +1,107 @@
+/*
+ * $Id: vecsum.cc,v 1.3 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECSUM_CC
+#define BZ_VECSUM_CC
+
+#ifndef BZ_VECGLOBS_H
+ #error <blitz/vecsum.cc> must be included via <blitz/vecglobs.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr>
+inline
+BZ_SUMTYPE(_bz_typename P_expr::T_numtype)
+_bz_vec_sum(P_expr vector)
+{
+    typedef _bz_typename P_expr::T_numtype T_numtype;
+    typedef BZ_SUMTYPE(T_numtype)          T_sumtype;
+
+    T_sumtype sum = 0;
+    int length = vector._bz_suggestLength();
+
+    if (vector._bz_hasFastAccess())
+    {
+        for (int i=0; i < length; ++i)
+            sum += vector._bz_fastAccess(i);
+    }
+    else {
+        for (int i=0; i < length; ++i)
+            sum += vector(i);
+    }
+
+    return sum;
+}
+
+template<typename P_numtype>
+inline
+BZ_SUMTYPE(P_numtype) sum(const Vector<P_numtype>& x)
+{
+    return _bz_vec_sum(x._bz_asVecExpr());
+}
+
+// sum(expr)
+template<typename P_expr>
+inline
+BZ_SUMTYPE(_bz_typename P_expr::T_numtype)
+sum(_bz_VecExpr<P_expr> expr)
+{
+    return _bz_vec_sum(expr);
+}
+
+// sum(vecpick)
+template<typename P_numtype>
+inline
+BZ_SUMTYPE(P_numtype)
+sum(const VectorPick<P_numtype>& x)
+{
+    return _bz_vec_sum(x._bz_asVecExpr());
+}
+
+// mean(vector)
+template<typename P_numtype>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype)) mean(const Vector<P_numtype>& x)
+{
+    BZPRECONDITION(x.length() > 0);
+
+    typedef BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype)) T_floattype;
+    return _bz_vec_sum(x._bz_asVecExpr()) / (T_floattype) x.length();
+}
+
+// mean(expr)
+template<typename P_expr>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(_bz_typename P_expr::T_numtype))
+mean(_bz_VecExpr<P_expr> expr)
+{
+    BZPRECONDITION(expr._bz_suggestLength() > 0);
+
+    typedef BZ_FLOATTYPE(BZ_SUMTYPE(_bz_typename P_expr::T_numtype)) 
+        T_floattype;
+    return _bz_vec_sum(expr) / (T_floattype) expr._bz_suggestLength();
+}
+
+// mean(vecpick)
+template<typename P_numtype>
+inline
+BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype))
+mean(const VectorPick<P_numtype>& x)
+{
+    BZPRECONDITION(x.length() > 0);
+
+    typedef BZ_FLOATTYPE(BZ_SUMTYPE(P_numtype)) T_floattype;
+    return _bz_vec_sum(x._bz_asVecExpr()) / (T_floattype) x.length();
+}
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECSUM_CC
+
Index: /XMLIO_V2/external/include/blitz/vector-et.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vector-et.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vector-et.h	(revision 73)
@@ -0,0 +1,39 @@
+/***************************************************************************
+ * blitz/vector-et.h      Vector<P_numtype> class + expression templates
+ *
+ * $Id: vector-et.h,v 1.2 2003/01/14 11:29:18 patricg Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+#ifndef BZ_VECTOR_ET_H
+#define BZ_VECTOR_ET_H
+
+#include <blitz/vector.h>
+
+// These are compile-time expensive things not included
+// by <blitz/vector.h>, but needed if we want vector expressions.
+
+#include <blitz/vecbops.cc>         // Operators with two operands
+#include <blitz/vecuops.cc>         // Functions with one argument
+#include <blitz/vecbfn.cc>          // Functions with two arguments
+
+#endif  // BZ_VECTOR_ET_H
+
Index: /XMLIO_V2/external/include/blitz/vector.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vector.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vector.cc	(revision 73)
@@ -0,0 +1,847 @@
+/*
+ * $Id: vector.cc,v 1.7 2005/10/06 23:28:03 julianc Exp $
+ *
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_VECTOR_CC
+#define BZ_VECTOR_CC
+
+#include <blitz/vector.h>
+#include <blitz/update.h>
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype>
+Vector<P_numtype> Vector<P_numtype>::copy() const
+{
+    Vector<P_numtype> newCopy(length_);
+
+    if (stride_ == 1)
+    {
+        memcpy(newCopy.data(), data(), length_ * sizeof(P_numtype));
+    }
+    else {
+        for (int i=0; i < length_; ++i)
+        {
+            // Can assume that newCopy has unit stride, and hence use
+            // the operator(), which assumes unit stride.  Since this
+            // vector doesn't have unit stride, use [].
+            newCopy(i) = (*this)[i];
+        }
+    }
+
+    return newCopy;
+}
+
+template<typename P_numtype>
+void Vector<P_numtype>::makeUnique()
+{
+    if ((stride_ != 1) || (this->numReferences() > 1))
+    {
+        Vector<P_numtype> tmp = copy();
+        reference(tmp);
+    }
+}
+
+template<typename P_numtype>
+void Vector<P_numtype>::reference(Vector<P_numtype>& x)
+{
+    MemoryBlockReference<P_numtype>::changeBlock(x);
+    length_ = x.length_;
+    stride_ = x.stride_;
+}
+
+template<typename P_numtype>
+void Vector<P_numtype>::resize(int length)
+{
+    if (length != length_)
+    {
+        MemoryBlockReference<P_numtype>::newBlock(length);
+        length_ = length;
+        stride_ = 1;
+    }
+}
+
+template<typename P_numtype>
+void Vector<P_numtype>::resizeAndPreserve(int newLength)
+{
+    Vector<P_numtype> newVector(newLength);
+
+    if (newLength > length_)
+        newVector(Range(0,length_-1)) = (*this);
+    else 
+        newVector(Range(0,newLength-1)) = (*this);
+
+    reference(newVector);
+}
+
+/*****************************************************************************
+ * Assignment operators with vector expression operand
+ */
+
+template<typename P_numtype> template<typename P_expr, typename P_updater>
+inline
+void Vector<P_numtype>::_bz_assign(P_expr expr, P_updater)
+{
+    BZPRECONDITION(expr.length(length_) == length_);
+
+    // If all vectors in the expression, plus the vector to which the
+    // result is being assigned have unit stride, then avoid stride
+    // calculations.
+    if ((stride_ == 1) && (expr._bz_hasFastAccess()))
+    {
+#ifndef BZ_PARTIAL_LOOP_UNROLL
+        for (int i=0; i < length_; ++i)
+            P_updater::update(data_[i], expr._bz_fastAccess(i));
+#else
+        // Unwind the inner loop, four elements at a time.
+        int leftover = length_ & 0x03;
+
+        int i=0;
+        for (; i < leftover; ++i)
+            P_updater::update(data_[i], expr._bz_fastAccess(i));
+
+        for (; i < length_; i += 4)
+        {
+            // Common subexpression elimination: avoid doing i+1, i+2, i+3
+            // multiple times (compilers *won't* do this cse automatically)
+            int t1 = i+1;
+            int t2 = i+2;
+            int t3 = i+3;
+    
+            _bz_typename P_expr::T_numtype tmp1, tmp2, tmp3, tmp4;
+
+            // Reading all the results first avoids aliasing
+            // ambiguities, and provides more flexibility in
+            // register allocation & instruction scheduling
+            tmp1 = expr._bz_fastAccess(i);
+            tmp2 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t1));
+            tmp3 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t2));
+            tmp4 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t3));
+
+            P_updater::update(data_[i], BZ_NO_PROPAGATE(tmp1));
+            P_updater::update(data_[t1], tmp2);
+            P_updater::update(data_[t2], tmp3);
+            P_updater::update(data_[t3], tmp4);
+        }
+#endif
+    }
+    else {
+        // Not all unit strides -- have to access all the vector elements
+        // as data_[i*stride_], which is slower.
+        for (int i=0; i < length_; ++i)
+            P_updater::update((*this)[i], expr[i]);
+    }
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator=(_bz_VecExpr<P_expr> expr)
+{
+    BZPRECONDITION(expr.length(length_) == length_);
+
+    // If all vectors in the expression, plus the vector to which the
+    // result is being assigned have unit stride, then avoid stride
+    // calculations.
+    if ((stride_ == 1) && (expr._bz_hasFastAccess()))
+    {
+#ifndef BZ_PARTIAL_LOOP_UNROLL
+        for (int i=0; i < length_; ++i)
+            data_[i] = (P_numtype)expr._bz_fastAccess(i);
+#else
+        // Unwind the inner loop, four elements at a time.
+        int leftover = length_ & 3;
+
+        int i=0;
+        for (; i < leftover; ++i)
+            data_[i] = (P_numtype)expr._bz_fastAccess(i);
+
+        for (; i < length_; i += 4)
+        {
+            // Common subexpression elimination: avoid doing i+1, i+2, i+3
+            // multiple times (compilers *won't* do this cse automatically)
+            int t1 = i+1;
+            int t2 = i+2;
+            int t3 = i+3;
+
+            _bz_typename P_expr::T_numtype tmp1, tmp2, tmp3, tmp4;
+
+            // Reading all the results first avoids aliasing
+            // ambiguities, and provides more flexibility in
+            // register allocation & instruction scheduling
+            tmp1 = expr._bz_fastAccess(i);
+            tmp2 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t1));
+            tmp3 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t2));
+            tmp4 = expr._bz_fastAccess(BZ_NO_PROPAGATE(t3));
+
+            data_[i] = (P_numtype)BZ_NO_PROPAGATE(tmp1);
+            data_[t1] = (P_numtype)tmp2;
+            data_[t2] = (P_numtype)tmp3;
+            data_[t3] = (P_numtype)tmp4;
+        }
+#endif
+    }
+    else {
+        // Not all unit strides -- have to access all the vector elements
+        // as data_[i*stride_], which is slower.
+        for (int i=0; i < length_; ++i)
+            (*this)[i] = (P_numtype)expr[i];
+    }
+    return *this;
+}
+
+#ifdef BZ_PARTIAL_LOOP_UNROLL
+ 
+#define BZ_VECTOR_ASSIGN(op)                                            \
+template<typename P_numtype> template<typename P_expr>                        \
+inline Vector<P_numtype>& Vector<P_numtype>::                           \
+    operator op (_bz_VecExpr<P_expr> expr)                              \
+{                                                                       \
+    BZPRECONDITION(expr.length(length_) == length_);                    \
+    if ((stride_ == 1) && (expr._bz_hasFastAccess()))                   \
+    {                                                                   \
+        int leftover = length_ & 0x03;                                  \
+                                                                        \
+        int i=0;                                                        \
+        for (; i < leftover; ++i)                                       \
+            data_[i] op expr._bz_fastAccess(i);                         \
+                                                                        \
+        for (; i < length_; i += 4)                                     \
+        {                                                               \
+            int t1 = i+1;                                               \
+            int t2 = i+2;                                               \
+            int t3 = i+3;                                               \
+                                                                        \
+            _bz_typename P_expr::T_numtype tmp1, tmp2, tmp3, tmp4;      \
+                                                                        \
+            tmp1 = expr._bz_fastAccess(i);                              \
+            tmp2 = expr._bz_fastAccess(t1);                             \
+            tmp3 = expr._bz_fastAccess(t2);                             \
+            tmp4 = expr._bz_fastAccess(t3);                             \
+                                                                        \
+            data_[i] op tmp1;                                           \
+            data_[t1] op tmp2;                                          \
+            data_[t2] op tmp3;                                          \
+            data_[t3] op tmp4;                                          \
+        }                                                               \
+    }                                                                   \
+    else {                                                              \
+        for (int i=0; i < length_; ++i)                                 \
+            (*this)[i] op expr[i];                                      \
+    }                                                                   \
+    return *this;                                                       \
+}
+
+#else   // not BZ_PARTIAL_LOOP_UNROLL
+
+#ifdef BZ_ALTERNATE_FORWARD_BACKWARD_TRAVERSALS
+
+/*
+ * NEEDS_WORK: need to incorporate BZ_NO_PROPAGATE here.  This
+ * will require doing away with the macro BZ_VECTOR_ASSIGN, and
+ * adopting an approach similar to that used in arrayeval.cc.
+ */
+
+#define BZ_VECTOR_ASSIGN(op)                                            \
+template<typename P_numtype> template<typename P_expr>                        \
+inline Vector<P_numtype>& Vector<P_numtype>::                           \
+    operator op (_bz_VecExpr<P_expr> expr)                              \
+{                                                                       \
+    BZPRECONDITION(expr.length(length_) == length_);                    \
+    static int traversalOrder = 0;                                      \
+    if ((stride_ == 1) && (expr._bz_hasFastAccess()))                   \
+    {                                                                   \
+        if (traversalOrder & 0x01)                                      \
+            for (int i=length_-1; i >= 0; --i)                          \
+                data_[i] op expr._bz_fastAccess(i);                     \
+        else                                                            \
+            for (int i=0; i < length_; ++i)                             \
+                data_[i] op expr._bz_fastAccess(i);                     \
+    }                                                                   \
+    else {                                                              \
+        for (int i=0; i < length_; ++i)                                 \
+            (*this)[i] op expr[i];                                      \
+    }                                                                   \
+    traversalOrder ^= 0x01;                                             \
+    return *this;                                                       \
+}
+
+#else   // not BZ_ALTERNATE_FORWARD_BACKWARD_TRAVERSALS
+
+#define BZ_VECTOR_ASSIGN(op)                                            \
+template<typename P_numtype> template<typename P_expr>                        \
+inline Vector<P_numtype>& Vector<P_numtype>::                           \
+    operator op (_bz_VecExpr<P_expr> expr)                              \
+{                                                                       \
+    BZPRECONDITION(expr.length(length_) == length_);                    \
+    if ((stride_ == 1) && (expr._bz_hasFastAccess()))                   \
+    {                                                                   \
+        for (int i=0; i < length_; ++i)                                 \
+            data_[i] op expr._bz_fastAccess(i);                         \
+    }                                                                   \
+    else {                                                              \
+        for (int i=0; i < length_; ++i)                                 \
+            (*this)[i] op expr[i];                                      \
+    }                                                                   \
+    return *this;                                                       \
+}                 
+#endif // BZ_ALTERNATE_FORWARD_BACKWARD_TRAVERSALS
+#endif // BZ_PARTIAL_LOOP_UNROLL
+
+BZ_VECTOR_ASSIGN(+=)
+BZ_VECTOR_ASSIGN(-=)
+BZ_VECTOR_ASSIGN(*=)
+BZ_VECTOR_ASSIGN(/=)
+BZ_VECTOR_ASSIGN(%=)
+BZ_VECTOR_ASSIGN(^=)
+BZ_VECTOR_ASSIGN(&=)
+BZ_VECTOR_ASSIGN(|=)
+BZ_VECTOR_ASSIGN(>>=)
+BZ_VECTOR_ASSIGN(<<=)
+
+#if NOT_DEFINED
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator+=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_plus_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator-=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_minus_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator*=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_multiply_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator/=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_divide_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator%=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_mod_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator^=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_xor_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator&=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitand_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator|=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_bitor_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator>>=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftr_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_expr>
+inline Vector<P_numtype>& Vector<P_numtype>::operator<<=(_bz_VecExpr<P_expr> expr)
+{
+    _bz_assign(expr, _bz_shiftl_update<P_numtype,
+        _bz_typename P_expr::T_numtype>());
+    return *this;
+}
+#endif   // NOT_DEFINED
+
+/*****************************************************************************
+ * Assignment operators with scalar operand
+ */
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::initialize(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator+=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) += _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator-=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) -= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator*=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) *= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator/=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) /= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator%=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) %= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator^=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) ^= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator&=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) &= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator|=(P_numtype x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) |= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator>>=(int x)
+{
+    typedef _bz_VecExprConstant<int> T_expr;
+    (*this) >>= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator<<=(int x)
+{
+    typedef _bz_VecExprConstant<P_numtype> T_expr;
+    (*this) <<= _bz_VecExpr<T_expr>(T_expr(x));
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with vector operand
+ */
+
+// This version is for two vectors with the same template parameter.
+// Does not appear to be supported by the current C++ standard; or
+// is it?
+#if 0
+template<typename P_numtype> template<>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator=(const Vector<P_numtype>& x)
+{
+    // NEEDS_WORK: if unit strides, use memcpy or something similar.
+
+    typedef VectorIterConst<P_numtype> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(T_expr(*this));
+    return *this;
+}
+#endif
+
+// This version is for two vectors with *different* template
+// parameters.
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& 
+Vector<P_numtype>::operator=(const Vector<P_numtype2>& x)
+{
+    (*this) = _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator+=(const Vector<P_numtype2>& x)
+{
+    (*this) += _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator-=(const Vector<P_numtype2>& x)
+{
+    (*this) -= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator*=(const Vector<P_numtype2>& x)
+{
+    (*this) *= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator/=(const Vector<P_numtype2>& x)
+{
+    (*this) /= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator%=(const Vector<P_numtype2>& x)
+{
+    (*this) %= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator^=(const Vector<P_numtype2>& x)
+{
+    (*this) ^= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator&=(const Vector<P_numtype2>& x)
+{
+    (*this) &= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator|=(const Vector<P_numtype2>& x)
+{
+    (*this) |= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator<<=(const Vector<P_numtype2>& x)
+{
+    (*this) <<= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>&
+Vector<P_numtype>::operator>>=(const Vector<P_numtype2>& x)
+{
+    (*this) >>= _bz_VecExpr<VectorIterConst<P_numtype2> >(x.beginFast());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Range operand
+ */
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator=(Range r)
+{
+    (*this) = _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator+=(Range r)
+{
+    (*this) += _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator-=(Range r)
+{
+    (*this) -= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator*=(Range r)
+{
+    (*this) *= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator/=(Range r)
+{
+    (*this) /= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator%=(Range r)
+{
+    (*this) %= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator^=(Range r)
+{
+    (*this) ^= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator&=(Range r)
+{
+    (*this) &= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator|=(Range r)
+{
+    (*this) |= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator>>=(Range r)
+{
+    (*this) >>= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+template<typename P_numtype>
+inline Vector<P_numtype>& Vector<P_numtype>::operator<<=(Range r)
+{
+    (*this) <<= _bz_VecExpr<Range>(r);
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with VectorPick operand
+ */
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator=(const 
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) = _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator+=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) += _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator-=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) -= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator*=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) *= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator/=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) /= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator%=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) %= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator^=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) ^= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator&=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) &= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_numtype2>
+inline Vector<P_numtype>& Vector<P_numtype>::operator|=(const
+    VectorPick<P_numtype2>& x)
+{
+    typedef VectorPickIterConst<P_numtype2> T_expr;
+    (*this) |= _bz_VecExpr<T_expr>(x.beginFast());
+    return *this;
+}
+
+/*****************************************************************************
+ * Assignment operators with Random operand
+ */
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator=(Random<P_distribution>& rand)
+{
+    for (int i=0; i < length_; ++i) 
+        (*this)[i] = rand.random();
+    return *this;
+}
+
+#ifdef BZ_PECULIAR_RANDOM_VECTOR_ASSIGN_BUG
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator=(Random<P_distribution>& rand)
+{
+    (*this) = _bz_VecExpr<_bz_VecExprRandom<P_distribution> > 
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator+=(Random<P_distribution>& rand)
+{
+    (*this) += _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator-=(Random<P_distribution>& rand)
+{
+    (*this) -= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator*=(Random<P_distribution>& rand)
+{
+    (*this) *= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator/=(Random<P_distribution>& rand)
+{
+    (*this) /= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator%=(Random<P_distribution>& rand)
+{
+    (*this) %= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator^=(Random<P_distribution>& rand)
+{
+    (*this) ^= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator&=(Random<P_distribution>& rand)
+{
+    (*this) &= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+template<typename P_numtype> template<typename P_distribution>
+Vector<P_numtype>& Vector<P_numtype>::operator|=(Random<P_distribution>& rand)
+{
+    (*this) |= _bz_VecExpr<_bz_VecExprRandom<P_distribution> >
+        (_bz_VecExprRandom<P_distribution>(rand));
+    return *this;
+}
+
+#endif // BZ_PECULIAR_RANDOM_VECTOR_ASSIGN_BUG
+
+BZ_NAMESPACE_END
+
+#endif // BZ_VECTOR_CC
Index: /XMLIO_V2/external/include/blitz/vector.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vector.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vector.h	(revision 73)
@@ -0,0 +1,455 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/vector.h      Declaration of the Vector<P_numtype> class
+ *
+ * $Id: vector.h,v 1.10 2005/10/06 23:27:13 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ****************************************************************************/
+
+/*
+ * KNOWN BUGS
+ *
+ * 1. operator[](Vector<int>) won't match; compiler complains of no
+ *       suitable copy constructor for VectorPick<T>
+ * 2. Vector<T>(_bz_VecExpr<E>) constructor generates warning
+ * 3. operator+=,-=,..etc.(Random<D>) won't match; compiler complains of
+ *       no suitable copy constructor for _bz_VecExpr(...).
+ */
+
+#ifndef BZ_VECTOR_H
+#define BZ_VECTOR_H
+
+#include <blitz/blitz.h>
+#include <blitz/memblock.h>
+#include <blitz/range.h>
+#include <blitz/listinit.h>
+
+BZ_NAMESPACE(blitz)
+
+// Forward declarations
+template<typename P_numtype> class VectorIter;
+template<typename P_numtype> class VectorIterConst;
+template<typename P_expr>    class _bz_VecExpr;       
+template<typename P_numtype> class VectorPick;
+template<typename P_numtype> class Random;
+
+// Declaration of class Vector<P_numtype>
+
+template<typename P_numtype>
+class Vector : protected MemoryBlockReference<P_numtype> {
+  
+private:
+    typedef MemoryBlockReference<P_numtype> T_base;
+    using T_base::data_;
+
+public:
+    //////////////////////////////////////////////
+    // Public Types
+    //////////////////////////////////////////////
+
+    typedef P_numtype                  T_numtype;
+    typedef Vector<T_numtype>          T_vector;
+    typedef VectorIter<T_numtype>      T_iterator;
+    typedef VectorIterConst<T_numtype> T_constIterator;
+    typedef VectorPick<T_numtype>      T_pick;
+    typedef Vector<int>                T_indexVector;
+
+    //////////////////////////////////////////////
+    // Constructors                             //
+    //////////////////////////////////////////////
+    // Most of the constructors are inlined so that
+    // the setting of the stride_ data member will
+    // be visible to the optimizer.
+
+    Vector()
+    { 
+        length_ = 0;
+        stride_ = 0;
+    }
+
+    // This constructor is provided inline because it involves
+    // no memory allocation.
+    Vector(const Vector<T_numtype>& vec)
+        : MemoryBlockReference<T_numtype>(const_cast<Vector<T_numtype>&>(vec))
+    {
+        length_ = vec.length_;
+        stride_ = vec.stride_;
+    }
+
+    explicit Vector(int length)
+        : MemoryBlockReference<T_numtype>(length)
+    {
+        length_ = length;
+        stride_ = 1;
+    }
+
+    Vector(const Vector<T_numtype>& vec, Range r)
+        : MemoryBlockReference<T_numtype>(const_cast<Vector<T_numtype>&>(vec),
+                                          r.first() * vec.stride())
+    {
+        BZPRECONDITION((r.first() >= 0) && (r.first() < vec.length()));
+        BZPRECONDITION((r.last(vec.length()-1) >= 0) 
+            && (r.last(vec.length()-1) < vec.length()));
+        length_ = (r.last(vec.length()-1) - r.first()) / r.stride() + 1;
+        stride_ = vec.stride() * r.stride();
+    }
+
+    Vector(int length, T_numtype initValue)
+        : MemoryBlockReference<T_numtype>(length)
+    {
+        length_ = length;
+        stride_ = 1;
+        (*this) = initValue;
+    }
+
+    Vector(int length, T_numtype firstValue, T_numtype delta)
+        : MemoryBlockReference<T_numtype>(length)
+    {
+        length_ = length;
+        stride_ = 1;
+        for (int i=0; i < length; ++i)
+            data_[i] = firstValue + i * delta;
+    }
+
+    template<typename P_distribution>
+    Vector(int length, Random<P_distribution>& random)
+        : MemoryBlockReference<T_numtype>(length)
+    {
+        length_ = length;
+        stride_ = 1;
+        (*this) = random;
+    }
+
+    template<typename P_expr>
+    Vector(_bz_VecExpr<P_expr> expr)
+        : MemoryBlockReference<T_numtype>(expr._bz_suggestLength())
+    {
+        length_ = expr._bz_suggestLength();
+        stride_ = 1;
+        (*this) = expr;
+    }
+
+    // Create a vector view of an already allocated block of memory.
+    // Note that the memory will not be freed when this vector is
+    // destroyed.
+    Vector(int length, T_numtype* restrict data, int stride = 1)
+        : MemoryBlockReference<T_numtype>(length, data, neverDeleteData)
+    {
+        length_ = length;
+        stride_ = stride;
+    }
+
+    // Create a vector containing a range of numbers
+    Vector(Range r)
+        : MemoryBlockReference<T_numtype>(r._bz_suggestLength())
+    {
+        length_ = r._bz_suggestLength();
+        stride_ = 1;
+        (*this) = _bz_VecExpr<Range>(r);
+    }
+    
+    //////////////////////////////////////////////
+    // Member functions
+    //////////////////////////////////////////////
+
+    // assertUnitStride() is provided as an optimizing trick.  When
+    // vectors are constructed outside the function scope, the optimizer
+    // is unaware that they have unit stride.  This function sets the
+    // stride to 1 in the local scope so the optimizer can do copy
+    // propagation & dead code elimination.  Obviously, you don't
+    // want to use this routine unless you are certain that the
+    // vectors have unit stride.
+    void            assertUnitStride()
+    {
+        BZPRECONDITION(stride_ == 1);
+        stride_ = 1;
+    }
+
+    T_iterator      beginFast()        { return T_iterator(*this);      }
+    T_constIterator beginFast()  const { return T_constIterator(*this); }
+
+    T_vector        copy()   const;
+
+    // T_iterator      end();
+    // T_constIterator end()    const;
+
+    T_numtype * restrict data()  
+    { return data_; }
+
+    const T_numtype * restrict data() const
+    { return data_; }
+
+    bool        isUnitStride() const
+    { return stride_ == 1; }
+
+    int        length() const
+    { return length_; }
+
+    void            makeUnique();
+
+    // int        storageSize() const;
+
+    // void            storeToBuffer(void* buffer, int bufferLength) const;
+
+    void            reference(T_vector&);
+
+    void            resize(int length);
+
+    void            resizeAndPreserve(int newLength);
+
+    // int             restoreFromBuffer(void* buffer, int bufferLength);
+
+    T_vector        reverse()
+    { return T_vector(*this,Range(length()-1,0,-1)); }
+
+    int             stride() const
+    { return stride_; }
+
+    operator _bz_VecExpr<VectorIterConst<T_numtype> > () const
+    { return _bz_VecExpr<VectorIterConst<T_numtype> >(beginFast()); }
+
+    /////////////////////////////////////////////
+    // Library-internal member functions
+    // These are undocumented and may change or
+    // disappear in future releases.
+    /////////////////////////////////////////////
+
+    int        _bz_suggestLength() const
+    { return length_; }
+
+    bool        _bz_hasFastAccess() const
+    { return stride_ == 1; }
+
+    T_numtype&      _bz_fastAccess(int i)
+    { return data_[i]; }
+
+    T_numtype       _bz_fastAccess(int i) const
+    { return data_[i]; }
+
+    template<typename P_expr, typename P_updater>
+    void            _bz_assign(P_expr, P_updater);
+
+    _bz_VecExpr<T_constIterator> _bz_asVecExpr() const
+    { return _bz_VecExpr<T_constIterator>(beginFast()); }
+
+    //////////////////////////////////////////////
+    // Subscripting operators
+    //////////////////////////////////////////////
+
+    // operator()(int) may be used only when the vector has unit
+    // stride.  Otherwise, use operator[].
+    T_numtype        operator()(int i) const
+    {
+        BZPRECONDITION(i < length_);
+        BZPRECONDITION(stride_ == 1);
+        return data_[i];
+    }
+
+    // operator()(int) may be used only when the vector has unit
+    // stride.  Otherwise, use operator[].
+    T_numtype& restrict operator()(int i) 
+    {
+        BZPRECONDITION(i < length_);
+        BZPRECONDITION(stride_ == 1);
+        return data_[i];
+    }
+
+    T_numtype        operator[](int i) const
+    {
+        BZPRECONDITION(i < length_);
+        return data_[i * stride_];
+    }
+
+    T_numtype& restrict operator[](int i)
+    {
+        BZPRECONDITION(i < length_);
+        return data_[i * stride_];
+    }
+
+    T_vector      operator()(Range r)
+    {
+        return T_vector(*this, r);
+    }
+
+    T_vector      operator[](Range r)
+    {
+        return T_vector(*this, r);
+    }
+
+    T_pick        operator()(T_indexVector i)
+    {
+        return T_pick(*this, i);
+    }
+
+    T_pick        operator[](T_indexVector i)
+    {
+        return T_pick(*this, i);
+    }
+
+    // T_vector      operator()(difference-equation-expression)
+
+    //////////////////////////////////////////////
+    // Assignment operators
+    //////////////////////////////////////////////
+
+    // Scalar operand
+    ListInitializationSwitch<T_vector,T_iterator> operator=(T_numtype x)
+    {
+        return ListInitializationSwitch<T_vector,T_iterator>(*this, x);
+    }
+
+    T_iterator getInitializationIterator()
+    { return beginFast(); }
+
+    T_vector& initialize(T_numtype);
+    T_vector& operator+=(T_numtype);
+    T_vector& operator-=(T_numtype);
+    T_vector& operator*=(T_numtype);
+    T_vector& operator/=(T_numtype);
+    T_vector& operator%=(T_numtype);
+    T_vector& operator^=(T_numtype);
+    T_vector& operator&=(T_numtype);
+    T_vector& operator|=(T_numtype);
+    T_vector& operator>>=(int);
+    T_vector& operator<<=(int); 
+
+    // Vector operand
+   
+    template<typename P_numtype2> T_vector& operator=(const Vector<P_numtype2> &);
+
+    // Specialization uses memcpy instead of element-by-element cast and
+    // copy
+    // NEEDS_WORK -- KCC won't accept this syntax; standard??
+    // template<> T_vector& operator=(const T_vector&);
+
+    template<typename P_numtype2> T_vector& operator+=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator-=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator*=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator/=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator%=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator^=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator&=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator|=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator>>=(const Vector<P_numtype2> &);
+    template<typename P_numtype2> T_vector& operator<<=(const Vector<P_numtype2> &);
+
+    // Vector expression operand
+    template<typename P_expr> T_vector& operator=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator+=(_bz_VecExpr<P_expr>); 
+    template<typename P_expr> T_vector& operator-=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator*=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator/=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator%=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator^=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator&=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator|=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator>>=(_bz_VecExpr<P_expr>);
+    template<typename P_expr> T_vector& operator<<=(_bz_VecExpr<P_expr>);
+    
+    // VectorPick operand
+    template<typename P_numtype2> 
+    T_vector& operator=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_vector& operator+=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_vector& operator-=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_vector& operator*=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2> 
+    T_vector& operator/=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator%=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator^=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator&=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator|=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator>>=(const VectorPick<P_numtype2> &);
+    template<typename P_numtype2>
+    T_vector& operator<<=(const VectorPick<P_numtype2> &);
+
+    // Range operand
+    T_vector& operator=(Range);
+    T_vector& operator+=(Range);
+    T_vector& operator-=(Range);
+    T_vector& operator*=(Range);
+    T_vector& operator/=(Range);
+    T_vector& operator%=(Range);
+    T_vector& operator^=(Range);
+    T_vector& operator&=(Range);
+    T_vector& operator|=(Range);
+    T_vector& operator>>=(Range);
+    T_vector& operator<<=(Range);
+
+    // Random operand
+    template<typename P_distribution>
+    T_vector& operator=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator+=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator-=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator*=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator/=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator%=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator^=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator&=(Random<P_distribution>& random);
+    template<typename P_distribution>
+    T_vector& operator|=(Random<P_distribution>& random);
+
+    //////////////////////////////////////////////
+    // Unary operators
+    //////////////////////////////////////////////
+
+//    T_vector& operator++();
+//    void operator++(int);
+//    T_vector& operator--();
+//    void operator--(int);
+    
+private:
+    int      length_;
+    int      stride_;
+};
+
+// Global I/O functions
+
+template<typename P_numtype>
+ostream& operator<<(ostream& os, const Vector<P_numtype>& x);
+
+template<typename P_expr>
+ostream& operator<<(ostream& os, _bz_VecExpr<P_expr> expr);
+
+BZ_NAMESPACE_END
+
+#include <blitz/veciter.h>          // Iterators
+#include <blitz/vecpick.h>          // VectorPick
+#include <blitz/vecexpr.h>          // Expression template classes
+#include <blitz/vecglobs.h>         // Global functions
+#include <blitz/vector.cc>          // Member functions
+#include <blitz/vecio.cc>           // IO functions
+
+#endif // BZ_VECTOR_H
Index: /XMLIO_V2/external/include/blitz/vecuops.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecuops.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecuops.cc	(revision 73)
@@ -0,0 +1,11813 @@
+/***************************************************************************
+ * blitz/../vecuops.cc	Expression templates for vectors, unary functions
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-suggest@cybervision.com
+ * Bugs:                 blitz-bugs@cybervision.com
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://seurat.uwaterloo.ca/blitz/
+ *
+ ***************************************************************************
+ *
+ */ 
+
+// Generated source file.  Do not edit. 
+// genvecuops.cpp Oct  6 2005 15:58:48
+
+#ifndef BZ_VECUOPS_CC
+#define BZ_VECUOPS_CC
+
+#ifndef BZ_VECEXPR_H
+ #error <blitz/vecuops.cc> must be included via <blitz/vecexpr.h>
+#endif // BZ_VECEXPR_H
+
+BZ_NAMESPACE(blitz)
+
+/****************************************************************************
+ * abs
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_abs<P_numtype1> > >
+abs(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_abs<typename P_expr1::T_numtype> > >
+abs(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_abs<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_abs<P_numtype1> > >
+abs(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_abs<int> > >
+abs(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_abs<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_abs<P_numtype1> > >
+abs(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * acos
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_acos<P_numtype1> > >
+acos(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_acos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_acos<typename P_expr1::T_numtype> > >
+acos(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_acos<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_acos<P_numtype1> > >
+acos(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_acos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_acos<int> > >
+acos(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_acos<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_acos<P_numtype1> > >
+acos(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_acos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * acosh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_acosh<P_numtype1> > >
+acosh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_acosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_acosh<typename P_expr1::T_numtype> > >
+acosh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_acosh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_acosh<P_numtype1> > >
+acosh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_acosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_acosh<int> > >
+acosh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_acosh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_acosh<P_numtype1> > >
+acosh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_acosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * asin
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_asin<P_numtype1> > >
+asin(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_asin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_asin<typename P_expr1::T_numtype> > >
+asin(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_asin<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_asin<P_numtype1> > >
+asin(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_asin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_asin<int> > >
+asin(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_asin<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_asin<P_numtype1> > >
+asin(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_asin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * asinh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_asinh<P_numtype1> > >
+asinh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_asinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_asinh<typename P_expr1::T_numtype> > >
+asinh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_asinh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_asinh<P_numtype1> > >
+asinh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_asinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_asinh<int> > >
+asinh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_asinh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_asinh<P_numtype1> > >
+asinh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_asinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * atan
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_atan<P_numtype1> > >
+atan(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_atan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_atan<typename P_expr1::T_numtype> > >
+atan(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_atan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_atan<P_numtype1> > >
+atan(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_atan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_atan<int> > >
+atan(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_atan<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_atan<P_numtype1> > >
+atan(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_atan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * atan2
+ ****************************************************************************/
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
+atan2(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_atan2<P_numtype1,float> > >
+atan2(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_atan2<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_atan2<P_numtype1,double> > >
+atan2(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_atan2<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_atan2<P_numtype1,long double> > >
+atan2(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_atan2<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_atan2<P_numtype1,complex<T2> > > >
+atan2(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
+atan2(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+atan2(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
+atan2(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_atan2<typename P_expr1::T_numtype,int> > >
+atan2(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_atan2<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > >
+atan2(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_atan2<typename P_expr1::T_numtype,int> > >
+atan2(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_atan2<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_atan2<typename P_expr1::T_numtype,float> > >
+atan2(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_atan2<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_atan2<typename P_expr1::T_numtype,double> > >
+atan2(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_atan2<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_atan2<typename P_expr1::T_numtype,long double> > >
+atan2(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_atan2<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > >
+atan2(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_atan2<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
+atan2(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_atan2<P_numtype1,float> > >
+atan2(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_atan2<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_atan2<P_numtype1,double> > >
+atan2(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_atan2<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_atan2<P_numtype1,long double> > >
+atan2(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_atan2<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_atan2<P_numtype1,complex<T2> > > >
+atan2(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_atan2<int,typename P_expr2::T_numtype> > >
+atan2(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_atan2<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_atan2<int,int> > >
+atan2(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_atan2<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_atan2<int,int> > >
+atan2(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_atan2<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_atan2<int,float> > >
+atan2(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_atan2<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_atan2<int,double> > >
+atan2(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_atan2<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_atan2<int,long double> > >
+atan2(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_atan2<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_atan2<int,complex<T2> > > >
+atan2(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_atan2<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<P_numtype1,P_numtype2> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_atan2<P_numtype1,int> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_atan2<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_atan2<P_numtype1,float> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_atan2<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_atan2<P_numtype1,double> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_atan2<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_atan2<P_numtype1,long double> > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_atan2<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_atan2<P_numtype1,complex<T2> > > >
+atan2(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_atan2<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<int,typename P_expr2::T_numtype> > >
+atan2(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_atan2<int,int> > >
+atan2(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_atan2<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<int,P_numtype2> > >
+atan2(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_atan2<float,P_numtype2> > >
+atan2(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_atan2<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<float,typename P_expr2::T_numtype> > >
+atan2(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<float,P_numtype2> > >
+atan2(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_atan2<float,int> > >
+atan2(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_atan2<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<float,P_numtype2> > >
+atan2(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_atan2<double,P_numtype2> > >
+atan2(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_atan2<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<double,typename P_expr2::T_numtype> > >
+atan2(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<double,P_numtype2> > >
+atan2(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_atan2<double,int> > >
+atan2(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_atan2<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<double,P_numtype2> > >
+atan2(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_atan2<long double,P_numtype2> > >
+atan2(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_atan2<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_atan2<long double,typename P_expr2::T_numtype> > >
+atan2(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_atan2<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_atan2<long double,P_numtype2> > >
+atan2(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_atan2<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_atan2<long double,int> > >
+atan2(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_atan2<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<long double,P_numtype2> > >
+atan2(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_atan2<complex<T1> ,P_numtype2> > >
+atan2(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > >
+atan2(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_atan2<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_atan2<complex<T1> ,P_numtype2> > >
+atan2(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_atan2<complex<T1> ,int> > >
+atan2(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_atan2<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_atan2<complex<T1> ,P_numtype2> > >
+atan2(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_atan2<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+
+/****************************************************************************
+ * atanh
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_atanh<P_numtype1> > >
+atanh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_atanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_atanh<typename P_expr1::T_numtype> > >
+atanh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_atanh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_atanh<P_numtype1> > >
+atanh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_atanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_atanh<int> > >
+atanh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_atanh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_atanh<P_numtype1> > >
+atanh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_atanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * _class
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz__class<P_numtype1> > >
+_class(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz__class<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz__class<typename P_expr1::T_numtype> > >
+_class(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz__class<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz__class<P_numtype1> > >
+_class(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz__class<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz__class<int> > >
+_class(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz__class<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz__class<P_numtype1> > >
+_class(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz__class<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * cbrt
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_cbrt<P_numtype1> > >
+cbrt(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_cbrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_cbrt<typename P_expr1::T_numtype> > >
+cbrt(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_cbrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_cbrt<P_numtype1> > >
+cbrt(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_cbrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_cbrt<int> > >
+cbrt(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_cbrt<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_cbrt<P_numtype1> > >
+cbrt(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_cbrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * ceil
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_ceil<P_numtype1> > >
+ceil(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_ceil<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_ceil<typename P_expr1::T_numtype> > >
+ceil(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_ceil<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_ceil<P_numtype1> > >
+ceil(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_ceil<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_ceil<int> > >
+ceil(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_ceil<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_ceil<P_numtype1> > >
+ceil(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_ceil<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * conj
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_COMPLEX_FCNS
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_conj<P_numtype1> > >
+conj(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_conj<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_conj<typename P_expr1::T_numtype> > >
+conj(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_conj<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_conj<P_numtype1> > >
+conj(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_conj<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_conj<int> > >
+conj(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_conj<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_conj<P_numtype1> > >
+conj(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_conj<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * copysign
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
+copysign(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_copysign<P_numtype1,float> > >
+copysign(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_copysign<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_copysign<P_numtype1,double> > >
+copysign(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_copysign<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_copysign<P_numtype1,long double> > >
+copysign(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_copysign<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_copysign<P_numtype1,complex<T2> > > >
+copysign(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
+copysign(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+copysign(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
+copysign(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_copysign<typename P_expr1::T_numtype,int> > >
+copysign(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_copysign<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > >
+copysign(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_copysign<typename P_expr1::T_numtype,int> > >
+copysign(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_copysign<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_copysign<typename P_expr1::T_numtype,float> > >
+copysign(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_copysign<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_copysign<typename P_expr1::T_numtype,double> > >
+copysign(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_copysign<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_copysign<typename P_expr1::T_numtype,long double> > >
+copysign(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_copysign<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > >
+copysign(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_copysign<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
+copysign(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_copysign<P_numtype1,float> > >
+copysign(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_copysign<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_copysign<P_numtype1,double> > >
+copysign(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_copysign<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_copysign<P_numtype1,long double> > >
+copysign(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_copysign<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_copysign<P_numtype1,complex<T2> > > >
+copysign(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_copysign<int,typename P_expr2::T_numtype> > >
+copysign(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_copysign<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_copysign<int,int> > >
+copysign(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_copysign<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_copysign<int,int> > >
+copysign(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_copysign<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_copysign<int,float> > >
+copysign(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_copysign<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_copysign<int,double> > >
+copysign(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_copysign<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_copysign<int,long double> > >
+copysign(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_copysign<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_copysign<int,complex<T2> > > >
+copysign(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_copysign<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<P_numtype1,P_numtype2> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_copysign<P_numtype1,int> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_copysign<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_copysign<P_numtype1,float> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_copysign<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_copysign<P_numtype1,double> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_copysign<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_copysign<P_numtype1,long double> > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_copysign<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_copysign<P_numtype1,complex<T2> > > >
+copysign(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_copysign<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<int,typename P_expr2::T_numtype> > >
+copysign(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_copysign<int,int> > >
+copysign(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_copysign<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<int,P_numtype2> > >
+copysign(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_copysign<float,P_numtype2> > >
+copysign(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_copysign<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<float,typename P_expr2::T_numtype> > >
+copysign(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<float,P_numtype2> > >
+copysign(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_copysign<float,int> > >
+copysign(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_copysign<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<float,P_numtype2> > >
+copysign(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_copysign<double,P_numtype2> > >
+copysign(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_copysign<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<double,typename P_expr2::T_numtype> > >
+copysign(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<double,P_numtype2> > >
+copysign(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_copysign<double,int> > >
+copysign(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_copysign<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<double,P_numtype2> > >
+copysign(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_copysign<long double,P_numtype2> > >
+copysign(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_copysign<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_copysign<long double,typename P_expr2::T_numtype> > >
+copysign(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_copysign<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_copysign<long double,P_numtype2> > >
+copysign(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_copysign<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_copysign<long double,int> > >
+copysign(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_copysign<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<long double,P_numtype2> > >
+copysign(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_copysign<complex<T1> ,P_numtype2> > >
+copysign(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > >
+copysign(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_copysign<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_copysign<complex<T1> ,P_numtype2> > >
+copysign(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_copysign<complex<T1> ,int> > >
+copysign(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_copysign<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_copysign<complex<T1> ,P_numtype2> > >
+copysign(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_copysign<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * cos
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_cos<P_numtype1> > >
+cos(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_cos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_cos<typename P_expr1::T_numtype> > >
+cos(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_cos<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_cos<P_numtype1> > >
+cos(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_cos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_cos<int> > >
+cos(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_cos<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_cos<P_numtype1> > >
+cos(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_cos<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * cosh
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_cosh<P_numtype1> > >
+cosh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_cosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_cosh<typename P_expr1::T_numtype> > >
+cosh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_cosh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_cosh<P_numtype1> > >
+cosh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_cosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_cosh<int> > >
+cosh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_cosh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_cosh<P_numtype1> > >
+cosh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_cosh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * drem
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
+drem(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_drem<P_numtype1,int> > >
+drem(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_drem<P_numtype1,int> > >
+drem(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_drem<P_numtype1,float> > >
+drem(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_drem<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_drem<P_numtype1,double> > >
+drem(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_drem<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_drem<P_numtype1,long double> > >
+drem(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_drem<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_drem<P_numtype1,complex<T2> > > >
+drem(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_drem<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
+drem(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+drem(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_drem<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
+drem(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_drem<typename P_expr1::T_numtype,int> > >
+drem(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_drem<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<typename P_expr1::T_numtype,P_numtype2> > >
+drem(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_drem<typename P_expr1::T_numtype,int> > >
+drem(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_drem<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_drem<typename P_expr1::T_numtype,float> > >
+drem(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_drem<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_drem<typename P_expr1::T_numtype,double> > >
+drem(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_drem<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_drem<typename P_expr1::T_numtype,long double> > >
+drem(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_drem<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_drem<typename P_expr1::T_numtype,complex<T2> > > >
+drem(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_drem<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
+drem(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_drem<P_numtype1,int> > >
+drem(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_drem<P_numtype1,int> > >
+drem(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_drem<P_numtype1,float> > >
+drem(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_drem<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_drem<P_numtype1,double> > >
+drem(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_drem<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_drem<P_numtype1,long double> > >
+drem(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_drem<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_drem<P_numtype1,complex<T2> > > >
+drem(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_drem<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_drem<int,P_numtype2> > >
+drem(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_drem<int,typename P_expr2::T_numtype> > >
+drem(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_drem<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_drem<int,P_numtype2> > >
+drem(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_drem<int,int> > >
+drem(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_drem<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<int,P_numtype2> > >
+drem(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_drem<int,int> > >
+drem(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_drem<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_drem<int,float> > >
+drem(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_drem<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_drem<int,double> > >
+drem(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_drem<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_drem<int,long double> > >
+drem(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_drem<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_drem<int,complex<T2> > > >
+drem(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_drem<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_drem<P_numtype1,typename P_expr2::T_numtype> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_drem<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_drem<P_numtype1,int> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<P_numtype1,P_numtype2> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_drem<P_numtype1,int> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_drem<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_drem<P_numtype1,float> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_drem<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_drem<P_numtype1,double> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_drem<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_drem<P_numtype1,long double> > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_drem<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_drem<P_numtype1,complex<T2> > > >
+drem(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_drem<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_drem<int,P_numtype2> > >
+drem(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_drem<int,typename P_expr2::T_numtype> > >
+drem(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_drem<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<int,P_numtype2> > >
+drem(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_drem<int,int> > >
+drem(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_drem<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<int,P_numtype2> > >
+drem(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_drem<float,P_numtype2> > >
+drem(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_drem<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_drem<float,typename P_expr2::T_numtype> > >
+drem(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_drem<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<float,P_numtype2> > >
+drem(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_drem<float,int> > >
+drem(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_drem<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<float,P_numtype2> > >
+drem(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_drem<double,P_numtype2> > >
+drem(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_drem<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_drem<double,typename P_expr2::T_numtype> > >
+drem(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_drem<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<double,P_numtype2> > >
+drem(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_drem<double,int> > >
+drem(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_drem<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<double,P_numtype2> > >
+drem(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_drem<long double,P_numtype2> > >
+drem(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_drem<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_drem<long double,typename P_expr2::T_numtype> > >
+drem(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_drem<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_drem<long double,P_numtype2> > >
+drem(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_drem<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_drem<long double,int> > >
+drem(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_drem<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<long double,P_numtype2> > >
+drem(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_drem<complex<T1> ,P_numtype2> > >
+drem(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > >
+drem(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_drem<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_drem<complex<T1> ,P_numtype2> > >
+drem(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_drem<complex<T1> ,int> > >
+drem(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_drem<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_drem<complex<T1> ,P_numtype2> > >
+drem(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_drem<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * exp
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_exp<P_numtype1> > >
+exp(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_exp<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_exp<typename P_expr1::T_numtype> > >
+exp(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_exp<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_exp<P_numtype1> > >
+exp(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_exp<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_exp<int> > >
+exp(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_exp<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_exp<P_numtype1> > >
+exp(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_exp<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * expm1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_expm1<P_numtype1> > >
+expm1(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_expm1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_expm1<typename P_expr1::T_numtype> > >
+expm1(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_expm1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_expm1<P_numtype1> > >
+expm1(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_expm1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_expm1<int> > >
+expm1(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_expm1<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_expm1<P_numtype1> > >
+expm1(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_expm1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * erf
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_erf<P_numtype1> > >
+erf(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_erf<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_erf<typename P_expr1::T_numtype> > >
+erf(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_erf<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_erf<P_numtype1> > >
+erf(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_erf<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_erf<int> > >
+erf(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_erf<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_erf<P_numtype1> > >
+erf(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_erf<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * erfc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_erfc<P_numtype1> > >
+erfc(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_erfc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_erfc<typename P_expr1::T_numtype> > >
+erfc(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_erfc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_erfc<P_numtype1> > >
+erfc(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_erfc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_erfc<int> > >
+erfc(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_erfc<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_erfc<P_numtype1> > >
+erfc(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_erfc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * fabs
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_abs<P_numtype1> > >
+fabs(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_abs<typename P_expr1::T_numtype> > >
+fabs(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_abs<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_abs<P_numtype1> > >
+fabs(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_abs<int> > >
+fabs(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_abs<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_abs<P_numtype1> > >
+fabs(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_abs<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * floor
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_floor<P_numtype1> > >
+floor(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_floor<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_floor<typename P_expr1::T_numtype> > >
+floor(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_floor<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_floor<P_numtype1> > >
+floor(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_floor<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_floor<int> > >
+floor(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_floor<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_floor<P_numtype1> > >
+floor(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_floor<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * fmod
+ ****************************************************************************/
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
+fmod(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_fmod<P_numtype1,float> > >
+fmod(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_fmod<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_fmod<P_numtype1,double> > >
+fmod(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_fmod<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_fmod<P_numtype1,long double> > >
+fmod(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_fmod<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_fmod<P_numtype1,complex<T2> > > >
+fmod(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
+fmod(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+fmod(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
+fmod(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_fmod<typename P_expr1::T_numtype,int> > >
+fmod(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_fmod<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > >
+fmod(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_fmod<typename P_expr1::T_numtype,int> > >
+fmod(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_fmod<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_fmod<typename P_expr1::T_numtype,float> > >
+fmod(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_fmod<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_fmod<typename P_expr1::T_numtype,double> > >
+fmod(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_fmod<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_fmod<typename P_expr1::T_numtype,long double> > >
+fmod(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_fmod<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > >
+fmod(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_fmod<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
+fmod(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_fmod<P_numtype1,float> > >
+fmod(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_fmod<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_fmod<P_numtype1,double> > >
+fmod(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_fmod<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_fmod<P_numtype1,long double> > >
+fmod(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_fmod<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_fmod<P_numtype1,complex<T2> > > >
+fmod(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_fmod<int,typename P_expr2::T_numtype> > >
+fmod(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_fmod<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_fmod<int,int> > >
+fmod(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_fmod<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_fmod<int,int> > >
+fmod(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_fmod<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_fmod<int,float> > >
+fmod(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_fmod<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_fmod<int,double> > >
+fmod(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_fmod<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_fmod<int,long double> > >
+fmod(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_fmod<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_fmod<int,complex<T2> > > >
+fmod(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_fmod<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<P_numtype1,P_numtype2> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_fmod<P_numtype1,int> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_fmod<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_fmod<P_numtype1,float> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_fmod<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_fmod<P_numtype1,double> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_fmod<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_fmod<P_numtype1,long double> > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_fmod<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_fmod<P_numtype1,complex<T2> > > >
+fmod(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_fmod<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<int,typename P_expr2::T_numtype> > >
+fmod(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_fmod<int,int> > >
+fmod(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_fmod<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<int,P_numtype2> > >
+fmod(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_fmod<float,P_numtype2> > >
+fmod(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_fmod<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<float,typename P_expr2::T_numtype> > >
+fmod(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<float,P_numtype2> > >
+fmod(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_fmod<float,int> > >
+fmod(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_fmod<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<float,P_numtype2> > >
+fmod(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_fmod<double,P_numtype2> > >
+fmod(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_fmod<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<double,typename P_expr2::T_numtype> > >
+fmod(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<double,P_numtype2> > >
+fmod(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_fmod<double,int> > >
+fmod(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_fmod<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<double,P_numtype2> > >
+fmod(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_fmod<long double,P_numtype2> > >
+fmod(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_fmod<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_fmod<long double,typename P_expr2::T_numtype> > >
+fmod(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_fmod<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_fmod<long double,P_numtype2> > >
+fmod(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_fmod<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_fmod<long double,int> > >
+fmod(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_fmod<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<long double,P_numtype2> > >
+fmod(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_fmod<complex<T1> ,P_numtype2> > >
+fmod(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > >
+fmod(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_fmod<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_fmod<complex<T1> ,P_numtype2> > >
+fmod(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_fmod<complex<T1> ,int> > >
+fmod(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_fmod<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_fmod<complex<T1> ,P_numtype2> > >
+fmod(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_fmod<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+
+/****************************************************************************
+ * hypot
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
+hypot(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_hypot<P_numtype1,float> > >
+hypot(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_hypot<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_hypot<P_numtype1,double> > >
+hypot(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_hypot<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_hypot<P_numtype1,long double> > >
+hypot(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_hypot<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_hypot<P_numtype1,complex<T2> > > >
+hypot(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
+hypot(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+hypot(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
+hypot(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_hypot<typename P_expr1::T_numtype,int> > >
+hypot(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_hypot<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > >
+hypot(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_hypot<typename P_expr1::T_numtype,int> > >
+hypot(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_hypot<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_hypot<typename P_expr1::T_numtype,float> > >
+hypot(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_hypot<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_hypot<typename P_expr1::T_numtype,double> > >
+hypot(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_hypot<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_hypot<typename P_expr1::T_numtype,long double> > >
+hypot(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_hypot<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > >
+hypot(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_hypot<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
+hypot(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_hypot<P_numtype1,float> > >
+hypot(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_hypot<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_hypot<P_numtype1,double> > >
+hypot(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_hypot<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_hypot<P_numtype1,long double> > >
+hypot(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_hypot<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_hypot<P_numtype1,complex<T2> > > >
+hypot(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_hypot<int,typename P_expr2::T_numtype> > >
+hypot(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_hypot<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_hypot<int,int> > >
+hypot(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_hypot<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_hypot<int,int> > >
+hypot(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_hypot<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_hypot<int,float> > >
+hypot(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_hypot<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_hypot<int,double> > >
+hypot(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_hypot<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_hypot<int,long double> > >
+hypot(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_hypot<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_hypot<int,complex<T2> > > >
+hypot(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_hypot<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<P_numtype1,P_numtype2> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_hypot<P_numtype1,int> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_hypot<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_hypot<P_numtype1,float> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_hypot<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_hypot<P_numtype1,double> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_hypot<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_hypot<P_numtype1,long double> > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_hypot<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_hypot<P_numtype1,complex<T2> > > >
+hypot(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_hypot<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<int,typename P_expr2::T_numtype> > >
+hypot(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_hypot<int,int> > >
+hypot(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_hypot<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<int,P_numtype2> > >
+hypot(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_hypot<float,P_numtype2> > >
+hypot(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_hypot<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<float,typename P_expr2::T_numtype> > >
+hypot(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<float,P_numtype2> > >
+hypot(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_hypot<float,int> > >
+hypot(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_hypot<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<float,P_numtype2> > >
+hypot(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_hypot<double,P_numtype2> > >
+hypot(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_hypot<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<double,typename P_expr2::T_numtype> > >
+hypot(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<double,P_numtype2> > >
+hypot(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_hypot<double,int> > >
+hypot(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_hypot<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<double,P_numtype2> > >
+hypot(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_hypot<long double,P_numtype2> > >
+hypot(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_hypot<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_hypot<long double,typename P_expr2::T_numtype> > >
+hypot(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_hypot<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_hypot<long double,P_numtype2> > >
+hypot(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_hypot<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_hypot<long double,int> > >
+hypot(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_hypot<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<long double,P_numtype2> > >
+hypot(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_hypot<complex<T1> ,P_numtype2> > >
+hypot(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > >
+hypot(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_hypot<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_hypot<complex<T1> ,P_numtype2> > >
+hypot(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_hypot<complex<T1> ,int> > >
+hypot(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_hypot<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_hypot<complex<T1> ,P_numtype2> > >
+hypot(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_hypot<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * ilogb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_ilogb<P_numtype1> > >
+ilogb(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_ilogb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_ilogb<typename P_expr1::T_numtype> > >
+ilogb(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_ilogb<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_ilogb<P_numtype1> > >
+ilogb(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_ilogb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_ilogb<int> > >
+ilogb(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_ilogb<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_ilogb<P_numtype1> > >
+ilogb(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_ilogb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * blitz_isnan
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_blitz_isnan<P_numtype1> > >
+blitz_isnan(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_blitz_isnan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_blitz_isnan<typename P_expr1::T_numtype> > >
+blitz_isnan(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_blitz_isnan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_blitz_isnan<P_numtype1> > >
+blitz_isnan(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_blitz_isnan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_blitz_isnan<int> > >
+blitz_isnan(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_blitz_isnan<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_blitz_isnan<P_numtype1> > >
+blitz_isnan(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_blitz_isnan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * itrunc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_itrunc<P_numtype1> > >
+itrunc(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_itrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_itrunc<typename P_expr1::T_numtype> > >
+itrunc(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_itrunc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_itrunc<P_numtype1> > >
+itrunc(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_itrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_itrunc<int> > >
+itrunc(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_itrunc<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_itrunc<P_numtype1> > >
+itrunc(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_itrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * j0
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_j0<P_numtype1> > >
+j0(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_j0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_j0<typename P_expr1::T_numtype> > >
+j0(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_j0<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_j0<P_numtype1> > >
+j0(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_j0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_j0<int> > >
+j0(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_j0<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_j0<P_numtype1> > >
+j0(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_j0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * j1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_j1<P_numtype1> > >
+j1(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_j1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_j1<typename P_expr1::T_numtype> > >
+j1(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_j1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_j1<P_numtype1> > >
+j1(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_j1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_j1<int> > >
+j1(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_j1<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_j1<P_numtype1> > >
+j1(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_j1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * lgamma
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_lgamma<P_numtype1> > >
+lgamma(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_lgamma<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_lgamma<typename P_expr1::T_numtype> > >
+lgamma(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_lgamma<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_lgamma<P_numtype1> > >
+lgamma(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_lgamma<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_lgamma<int> > >
+lgamma(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_lgamma<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_lgamma<P_numtype1> > >
+lgamma(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_lgamma<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * log
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_log<P_numtype1> > >
+log(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_log<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_log<typename P_expr1::T_numtype> > >
+log(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_log<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_log<P_numtype1> > >
+log(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_log<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_log<int> > >
+log(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_log<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_log<P_numtype1> > >
+log(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_log<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * logb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_logb<P_numtype1> > >
+logb(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_logb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_logb<typename P_expr1::T_numtype> > >
+logb(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_logb<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_logb<P_numtype1> > >
+logb(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_logb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_logb<int> > >
+logb(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_logb<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_logb<P_numtype1> > >
+logb(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_logb<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * log1p
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_log1p<P_numtype1> > >
+log1p(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_log1p<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_log1p<typename P_expr1::T_numtype> > >
+log1p(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_log1p<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_log1p<P_numtype1> > >
+log1p(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_log1p<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_log1p<int> > >
+log1p(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_log1p<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_log1p<P_numtype1> > >
+log1p(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_log1p<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * log10
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_log10<P_numtype1> > >
+log10(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_log10<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_log10<typename P_expr1::T_numtype> > >
+log10(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_log10<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_log10<P_numtype1> > >
+log10(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_log10<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_log10<int> > >
+log10(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_log10<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_log10<P_numtype1> > >
+log10(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_log10<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * nearest
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_nearest<P_numtype1> > >
+nearest(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_nearest<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_nearest<typename P_expr1::T_numtype> > >
+nearest(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_nearest<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_nearest<P_numtype1> > >
+nearest(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_nearest<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_nearest<int> > >
+nearest(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_nearest<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_nearest<P_numtype1> > >
+nearest(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_nearest<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * nextafter
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
+nextafter(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_nextafter<P_numtype1,float> > >
+nextafter(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_nextafter<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_nextafter<P_numtype1,double> > >
+nextafter(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_nextafter<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_nextafter<P_numtype1,long double> > >
+nextafter(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_nextafter<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_nextafter<P_numtype1,complex<T2> > > >
+nextafter(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
+nextafter(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+nextafter(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
+nextafter(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_nextafter<typename P_expr1::T_numtype,int> > >
+nextafter(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_nextafter<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > >
+nextafter(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_nextafter<typename P_expr1::T_numtype,int> > >
+nextafter(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_nextafter<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_nextafter<typename P_expr1::T_numtype,float> > >
+nextafter(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_nextafter<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_nextafter<typename P_expr1::T_numtype,double> > >
+nextafter(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_nextafter<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_nextafter<typename P_expr1::T_numtype,long double> > >
+nextafter(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_nextafter<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > >
+nextafter(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_nextafter<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
+nextafter(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_nextafter<P_numtype1,float> > >
+nextafter(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_nextafter<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_nextafter<P_numtype1,double> > >
+nextafter(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_nextafter<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_nextafter<P_numtype1,long double> > >
+nextafter(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_nextafter<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_nextafter<P_numtype1,complex<T2> > > >
+nextafter(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<int,typename P_expr2::T_numtype> > >
+nextafter(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_nextafter<int,int> > >
+nextafter(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_nextafter<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_nextafter<int,int> > >
+nextafter(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_nextafter<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_nextafter<int,float> > >
+nextafter(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_nextafter<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_nextafter<int,double> > >
+nextafter(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_nextafter<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_nextafter<int,long double> > >
+nextafter(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_nextafter<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_nextafter<int,complex<T2> > > >
+nextafter(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_nextafter<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<P_numtype1,P_numtype2> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_nextafter<P_numtype1,int> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_nextafter<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_nextafter<P_numtype1,float> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_nextafter<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_nextafter<P_numtype1,double> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_nextafter<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_nextafter<P_numtype1,long double> > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_nextafter<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_nextafter<P_numtype1,complex<T2> > > >
+nextafter(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_nextafter<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<int,typename P_expr2::T_numtype> > >
+nextafter(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_nextafter<int,int> > >
+nextafter(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_nextafter<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<int,P_numtype2> > >
+nextafter(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<float,P_numtype2> > >
+nextafter(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<float,typename P_expr2::T_numtype> > >
+nextafter(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<float,P_numtype2> > >
+nextafter(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_nextafter<float,int> > >
+nextafter(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_nextafter<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<float,P_numtype2> > >
+nextafter(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<double,P_numtype2> > >
+nextafter(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<double,typename P_expr2::T_numtype> > >
+nextafter(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<double,P_numtype2> > >
+nextafter(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_nextafter<double,int> > >
+nextafter(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_nextafter<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<double,P_numtype2> > >
+nextafter(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_nextafter<long double,P_numtype2> > >
+nextafter(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_nextafter<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_nextafter<long double,typename P_expr2::T_numtype> > >
+nextafter(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_nextafter<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<long double,P_numtype2> > >
+nextafter(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_nextafter<long double,int> > >
+nextafter(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_nextafter<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<long double,P_numtype2> > >
+nextafter(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_nextafter<complex<T1> ,P_numtype2> > >
+nextafter(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > >
+nextafter(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_nextafter<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_nextafter<complex<T1> ,P_numtype2> > >
+nextafter(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_nextafter<complex<T1> ,int> > >
+nextafter(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_nextafter<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_nextafter<complex<T1> ,P_numtype2> > >
+nextafter(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_nextafter<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * pow
+ ****************************************************************************/
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
+pow(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_pow<P_numtype1,int> > >
+pow(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_pow<P_numtype1,int> > >
+pow(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_pow<P_numtype1,float> > >
+pow(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_pow<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_pow<P_numtype1,double> > >
+pow(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_pow<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_pow<P_numtype1,long double> > >
+pow(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_pow<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_pow<P_numtype1,complex<T2> > > >
+pow(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_pow<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
+pow(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+pow(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_pow<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
+pow(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_pow<typename P_expr1::T_numtype,int> > >
+pow(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_pow<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<typename P_expr1::T_numtype,P_numtype2> > >
+pow(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_pow<typename P_expr1::T_numtype,int> > >
+pow(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_pow<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_pow<typename P_expr1::T_numtype,float> > >
+pow(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_pow<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_pow<typename P_expr1::T_numtype,double> > >
+pow(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_pow<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_pow<typename P_expr1::T_numtype,long double> > >
+pow(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_pow<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_pow<typename P_expr1::T_numtype,complex<T2> > > >
+pow(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_pow<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
+pow(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_pow<P_numtype1,int> > >
+pow(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_pow<P_numtype1,int> > >
+pow(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_pow<P_numtype1,float> > >
+pow(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_pow<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_pow<P_numtype1,double> > >
+pow(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_pow<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_pow<P_numtype1,long double> > >
+pow(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_pow<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_pow<P_numtype1,complex<T2> > > >
+pow(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_pow<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_pow<int,P_numtype2> > >
+pow(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_pow<int,typename P_expr2::T_numtype> > >
+pow(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_pow<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_pow<int,P_numtype2> > >
+pow(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_pow<int,int> > >
+pow(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_pow<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<int,P_numtype2> > >
+pow(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_pow<int,int> > >
+pow(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_pow<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_pow<int,float> > >
+pow(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_pow<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_pow<int,double> > >
+pow(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_pow<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_pow<int,long double> > >
+pow(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_pow<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_pow<int,complex<T2> > > >
+pow(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_pow<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_pow<P_numtype1,typename P_expr2::T_numtype> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_pow<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_pow<P_numtype1,int> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<P_numtype1,P_numtype2> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_pow<P_numtype1,int> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_pow<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_pow<P_numtype1,float> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_pow<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_pow<P_numtype1,double> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_pow<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_pow<P_numtype1,long double> > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_pow<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_pow<P_numtype1,complex<T2> > > >
+pow(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_pow<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_pow<int,P_numtype2> > >
+pow(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_pow<int,typename P_expr2::T_numtype> > >
+pow(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_pow<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<int,P_numtype2> > >
+pow(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_pow<int,int> > >
+pow(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_pow<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<int,P_numtype2> > >
+pow(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_pow<float,P_numtype2> > >
+pow(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_pow<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_pow<float,typename P_expr2::T_numtype> > >
+pow(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_pow<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<float,P_numtype2> > >
+pow(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_pow<float,int> > >
+pow(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_pow<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<float,P_numtype2> > >
+pow(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_pow<double,P_numtype2> > >
+pow(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_pow<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_pow<double,typename P_expr2::T_numtype> > >
+pow(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_pow<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<double,P_numtype2> > >
+pow(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_pow<double,int> > >
+pow(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_pow<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<double,P_numtype2> > >
+pow(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_pow<long double,P_numtype2> > >
+pow(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_pow<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_pow<long double,typename P_expr2::T_numtype> > >
+pow(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_pow<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_pow<long double,P_numtype2> > >
+pow(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_pow<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_pow<long double,int> > >
+pow(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_pow<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<long double,P_numtype2> > >
+pow(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_pow<complex<T1> ,P_numtype2> > >
+pow(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > >
+pow(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_pow<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_pow<complex<T1> ,P_numtype2> > >
+pow(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_pow<complex<T1> ,int> > >
+pow(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_pow<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_pow<complex<T1> ,P_numtype2> > >
+pow(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_pow<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+
+/****************************************************************************
+ * remainder
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
+remainder(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_remainder<P_numtype1,float> > >
+remainder(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_remainder<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_remainder<P_numtype1,double> > >
+remainder(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_remainder<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_remainder<P_numtype1,long double> > >
+remainder(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_remainder<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_remainder<P_numtype1,complex<T2> > > >
+remainder(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
+remainder(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+remainder(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
+remainder(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_remainder<typename P_expr1::T_numtype,int> > >
+remainder(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_remainder<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > >
+remainder(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_remainder<typename P_expr1::T_numtype,int> > >
+remainder(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_remainder<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_remainder<typename P_expr1::T_numtype,float> > >
+remainder(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_remainder<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_remainder<typename P_expr1::T_numtype,double> > >
+remainder(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_remainder<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_remainder<typename P_expr1::T_numtype,long double> > >
+remainder(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_remainder<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > >
+remainder(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_remainder<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
+remainder(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_remainder<P_numtype1,float> > >
+remainder(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_remainder<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_remainder<P_numtype1,double> > >
+remainder(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_remainder<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_remainder<P_numtype1,long double> > >
+remainder(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_remainder<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_remainder<P_numtype1,complex<T2> > > >
+remainder(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_remainder<int,typename P_expr2::T_numtype> > >
+remainder(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_remainder<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_remainder<int,int> > >
+remainder(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_remainder<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_remainder<int,int> > >
+remainder(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_remainder<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_remainder<int,float> > >
+remainder(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_remainder<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_remainder<int,double> > >
+remainder(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_remainder<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_remainder<int,long double> > >
+remainder(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_remainder<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_remainder<int,complex<T2> > > >
+remainder(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_remainder<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<P_numtype1,P_numtype2> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_remainder<P_numtype1,int> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_remainder<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_remainder<P_numtype1,float> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_remainder<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_remainder<P_numtype1,double> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_remainder<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_remainder<P_numtype1,long double> > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_remainder<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_remainder<P_numtype1,complex<T2> > > >
+remainder(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_remainder<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<int,typename P_expr2::T_numtype> > >
+remainder(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_remainder<int,int> > >
+remainder(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_remainder<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<int,P_numtype2> > >
+remainder(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_remainder<float,P_numtype2> > >
+remainder(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_remainder<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<float,typename P_expr2::T_numtype> > >
+remainder(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<float,P_numtype2> > >
+remainder(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_remainder<float,int> > >
+remainder(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_remainder<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<float,P_numtype2> > >
+remainder(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_remainder<double,P_numtype2> > >
+remainder(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_remainder<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<double,typename P_expr2::T_numtype> > >
+remainder(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<double,P_numtype2> > >
+remainder(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_remainder<double,int> > >
+remainder(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_remainder<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<double,P_numtype2> > >
+remainder(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_remainder<long double,P_numtype2> > >
+remainder(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_remainder<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_remainder<long double,typename P_expr2::T_numtype> > >
+remainder(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_remainder<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_remainder<long double,P_numtype2> > >
+remainder(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_remainder<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_remainder<long double,int> > >
+remainder(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_remainder<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<long double,P_numtype2> > >
+remainder(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_remainder<complex<T1> ,P_numtype2> > >
+remainder(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > >
+remainder(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_remainder<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_remainder<complex<T1> ,P_numtype2> > >
+remainder(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_remainder<complex<T1> ,int> > >
+remainder(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_remainder<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_remainder<complex<T1> ,P_numtype2> > >
+remainder(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_remainder<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * rint
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_rint<P_numtype1> > >
+rint(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_rint<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_rint<typename P_expr1::T_numtype> > >
+rint(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_rint<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_rint<P_numtype1> > >
+rint(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_rint<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_rint<int> > >
+rint(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_rint<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_rint<P_numtype1> > >
+rint(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_rint<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * rsqrt
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_rsqrt<P_numtype1> > >
+rsqrt(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_rsqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_rsqrt<typename P_expr1::T_numtype> > >
+rsqrt(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_rsqrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_rsqrt<P_numtype1> > >
+rsqrt(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_rsqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_rsqrt<int> > >
+rsqrt(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_rsqrt<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_rsqrt<P_numtype1> > >
+rsqrt(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_rsqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * scalb
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
+scalb(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_scalb<P_numtype1,float> > >
+scalb(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_scalb<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_scalb<P_numtype1,double> > >
+scalb(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_scalb<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_scalb<P_numtype1,long double> > >
+scalb(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_scalb<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_scalb<P_numtype1,complex<T2> > > >
+scalb(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
+scalb(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+scalb(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
+scalb(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_scalb<typename P_expr1::T_numtype,int> > >
+scalb(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_scalb<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > >
+scalb(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_scalb<typename P_expr1::T_numtype,int> > >
+scalb(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_scalb<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_scalb<typename P_expr1::T_numtype,float> > >
+scalb(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_scalb<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_scalb<typename P_expr1::T_numtype,double> > >
+scalb(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_scalb<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_scalb<typename P_expr1::T_numtype,long double> > >
+scalb(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_scalb<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > >
+scalb(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_scalb<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
+scalb(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_scalb<P_numtype1,float> > >
+scalb(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_scalb<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_scalb<P_numtype1,double> > >
+scalb(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_scalb<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_scalb<P_numtype1,long double> > >
+scalb(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_scalb<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_scalb<P_numtype1,complex<T2> > > >
+scalb(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_scalb<int,typename P_expr2::T_numtype> > >
+scalb(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_scalb<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_scalb<int,int> > >
+scalb(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_scalb<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_scalb<int,int> > >
+scalb(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_scalb<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_scalb<int,float> > >
+scalb(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_scalb<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_scalb<int,double> > >
+scalb(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_scalb<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_scalb<int,long double> > >
+scalb(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_scalb<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_scalb<int,complex<T2> > > >
+scalb(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_scalb<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<P_numtype1,P_numtype2> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_scalb<P_numtype1,int> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_scalb<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_scalb<P_numtype1,float> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_scalb<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_scalb<P_numtype1,double> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_scalb<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_scalb<P_numtype1,long double> > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_scalb<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_scalb<P_numtype1,complex<T2> > > >
+scalb(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_scalb<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<int,typename P_expr2::T_numtype> > >
+scalb(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_scalb<int,int> > >
+scalb(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_scalb<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<int,P_numtype2> > >
+scalb(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_scalb<float,P_numtype2> > >
+scalb(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_scalb<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<float,typename P_expr2::T_numtype> > >
+scalb(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<float,P_numtype2> > >
+scalb(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_scalb<float,int> > >
+scalb(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_scalb<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<float,P_numtype2> > >
+scalb(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_scalb<double,P_numtype2> > >
+scalb(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_scalb<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<double,typename P_expr2::T_numtype> > >
+scalb(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<double,P_numtype2> > >
+scalb(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_scalb<double,int> > >
+scalb(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_scalb<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<double,P_numtype2> > >
+scalb(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_scalb<long double,P_numtype2> > >
+scalb(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_scalb<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_scalb<long double,typename P_expr2::T_numtype> > >
+scalb(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_scalb<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_scalb<long double,P_numtype2> > >
+scalb(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_scalb<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_scalb<long double,int> > >
+scalb(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_scalb<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<long double,P_numtype2> > >
+scalb(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_scalb<complex<T1> ,P_numtype2> > >
+scalb(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > >
+scalb(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_scalb<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_scalb<complex<T1> ,P_numtype2> > >
+scalb(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_scalb<complex<T1> ,int> > >
+scalb(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_scalb<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_scalb<complex<T1> ,P_numtype2> > >
+scalb(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_scalb<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * sin
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_sin<P_numtype1> > >
+sin(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_sin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_sin<typename P_expr1::T_numtype> > >
+sin(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_sin<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_sin<P_numtype1> > >
+sin(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_sin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_sin<int> > >
+sin(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_sin<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_sin<P_numtype1> > >
+sin(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_sin<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * sinh
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_sinh<P_numtype1> > >
+sinh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_sinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_sinh<typename P_expr1::T_numtype> > >
+sinh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_sinh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_sinh<P_numtype1> > >
+sinh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_sinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_sinh<int> > >
+sinh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_sinh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_sinh<P_numtype1> > >
+sinh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_sinh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * sqr
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_sqr<P_numtype1> > >
+sqr(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_sqr<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_sqr<typename P_expr1::T_numtype> > >
+sqr(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_sqr<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_sqr<P_numtype1> > >
+sqr(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_sqr<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_sqr<int> > >
+sqr(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_sqr<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_sqr<P_numtype1> > >
+sqr(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_sqr<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * sqrt
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_sqrt<P_numtype1> > >
+sqrt(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_sqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_sqrt<typename P_expr1::T_numtype> > >
+sqrt(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_sqrt<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_sqrt<P_numtype1> > >
+sqrt(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_sqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_sqrt<int> > >
+sqrt(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_sqrt<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_sqrt<P_numtype1> > >
+sqrt(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_sqrt<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * tan
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_tan<P_numtype1> > >
+tan(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_tan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_tan<typename P_expr1::T_numtype> > >
+tan(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_tan<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_tan<P_numtype1> > >
+tan(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_tan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_tan<int> > >
+tan(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_tan<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_tan<P_numtype1> > >
+tan(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_tan<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * tanh
+ ****************************************************************************/
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_tanh<P_numtype1> > >
+tanh(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_tanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_tanh<typename P_expr1::T_numtype> > >
+tanh(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_tanh<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_tanh<P_numtype1> > >
+tanh(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_tanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_tanh<int> > >
+tanh(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_tanh<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_tanh<P_numtype1> > >
+tanh(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_tanh<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+/****************************************************************************
+ * uitrunc
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_uitrunc<P_numtype1> > >
+uitrunc(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_uitrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_uitrunc<typename P_expr1::T_numtype> > >
+uitrunc(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_uitrunc<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_uitrunc<P_numtype1> > >
+uitrunc(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_uitrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_uitrunc<int> > >
+uitrunc(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_uitrunc<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_uitrunc<P_numtype1> > >
+uitrunc(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_uitrunc<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * unordered
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_SYSTEM_V_MATH
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const Vector<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
+unordered(const Vector<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const Vector<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const Vector<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, Range,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const Vector<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const Vector<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_unordered<P_numtype1,float> > >
+unordered(const Vector<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_unordered<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_unordered<P_numtype1,double> > >
+unordered(const Vector<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_unordered<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_unordered<P_numtype1,long double> > >
+unordered(const Vector<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_unordered<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_unordered<P_numtype1,complex<T2> > > >
+unordered(const Vector<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
+unordered(_bz_VecExpr<P_expr1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorIterConst<P_numtype2>,
+        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > >
+unordered(_bz_VecExpr<P_expr1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<typename P_expr1::T_numtype,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
+unordered(_bz_VecExpr<P_expr1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+    _bz_unordered<typename P_expr1::T_numtype,int> > >
+unordered(_bz_VecExpr<P_expr1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, Range,
+        _bz_unordered<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > >
+unordered(_bz_VecExpr<P_expr1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<typename P_expr1::T_numtype,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+    _bz_unordered<typename P_expr1::T_numtype,int> > >
+unordered(_bz_VecExpr<P_expr1> d1, int d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<int>,
+        _bz_unordered<typename P_expr1::T_numtype,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+    _bz_unordered<typename P_expr1::T_numtype,float> > >
+unordered(_bz_VecExpr<P_expr1> d1, float d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<float>,
+        _bz_unordered<typename P_expr1::T_numtype,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+    _bz_unordered<typename P_expr1::T_numtype,double> > >
+unordered(_bz_VecExpr<P_expr1> d1, double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<double>,
+        _bz_unordered<typename P_expr1::T_numtype,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+    _bz_unordered<typename P_expr1::T_numtype,long double> > >
+unordered(_bz_VecExpr<P_expr1> d1, long double d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<long double>,
+        _bz_unordered<typename P_expr1::T_numtype,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > >
+unordered(_bz_VecExpr<P_expr1> d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExpr<P_expr1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_unordered<typename P_expr1::T_numtype,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const VectorPick<P_numtype1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
+unordered(const VectorPick<P_numtype1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const VectorPick<P_numtype1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const VectorPick<P_numtype1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, Range,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const VectorPick<P_numtype1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const VectorPick<P_numtype1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<int>,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+    _bz_unordered<P_numtype1,float> > >
+unordered(const VectorPick<P_numtype1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<float>,
+        _bz_unordered<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+    _bz_unordered<P_numtype1,double> > >
+unordered(const VectorPick<P_numtype1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<double>,
+        _bz_unordered<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+    _bz_unordered<P_numtype1,long double> > >
+unordered(const VectorPick<P_numtype1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<long double>,
+        _bz_unordered<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_unordered<P_numtype1,complex<T2> > > >
+unordered(const VectorPick<P_numtype1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<VectorPickIterConst<P_numtype1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(Range d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorIterConst<P_numtype2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+    _bz_unordered<int,typename P_expr2::T_numtype> > >
+unordered(Range d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExpr<P_expr2>,
+        _bz_unordered<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(Range d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<Range, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, Range,
+    _bz_unordered<int,int> > >
+unordered(Range d1, Range d2)
+{
+    typedef _bz_VecExprOp<Range, Range,
+        _bz_unordered<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(Range d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<Range, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+    _bz_unordered<int,int> > >
+unordered(Range d1, int d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<int>,
+        _bz_unordered<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<int>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+    _bz_unordered<int,float> > >
+unordered(Range d1, float d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<float>,
+        _bz_unordered<int,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<float>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+    _bz_unordered<int,double> > >
+unordered(Range d1, double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<double>,
+        _bz_unordered<int,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<double>(d2)));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+    _bz_unordered<int,long double> > >
+unordered(Range d1, long double d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<long double>,
+        _bz_unordered<int,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+    _bz_unordered<int,complex<T2> > > >
+unordered(Range d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<Range, _bz_VecExprConstant<complex<T2> > ,
+        _bz_unordered<int,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<P_numtype1,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, Range d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, Range,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2));
+}
+
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<P_numtype1,P_numtype2> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<P_numtype1,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), d2.beginFast()));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+    _bz_unordered<P_numtype1,int> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, int d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<int>,
+        _bz_unordered<P_numtype1,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<int>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+    _bz_unordered<P_numtype1,float> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, float d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<float>,
+        _bz_unordered<P_numtype1,float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<float>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+    _bz_unordered<P_numtype1,double> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<double>,
+        _bz_unordered<P_numtype1,double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<double>(d2)));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+    _bz_unordered<P_numtype1,long double> > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, long double d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<long double>,
+        _bz_unordered<P_numtype1,long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<long double>(d2)));
+}
+
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+    _bz_unordered<P_numtype1,complex<T2> > > >
+unordered(const TinyVector<P_numtype1, N_length1>& d1, complex<T2> d2)
+{
+    typedef _bz_VecExprOp<TinyVectorIterConst<P_numtype1, N_length1>, _bz_VecExprConstant<complex<T2> > ,
+        _bz_unordered<P_numtype1,complex<T2> > > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), _bz_VecExprConstant<complex<T2> > (d2)));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(int d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorIterConst<P_numtype2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<int,typename P_expr2::T_numtype> > >
+unordered(int d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<int,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(int d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+    _bz_unordered<int,int> > >
+unordered(int d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, Range,
+        _bz_unordered<int,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<int,P_numtype2> > >
+unordered(int d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<int>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<int,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<int>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+    _bz_unordered<float,P_numtype2> > >
+unordered(float d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorIterConst<P_numtype2>,
+        _bz_unordered<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<float,typename P_expr2::T_numtype> > >
+unordered(float d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<float,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<float,P_numtype2> > >
+unordered(float d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+    _bz_unordered<float,int> > >
+unordered(float d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, Range,
+        _bz_unordered<float,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<float,P_numtype2> > >
+unordered(float d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<float>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<float,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<float>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+    _bz_unordered<double,P_numtype2> > >
+unordered(double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorIterConst<P_numtype2>,
+        _bz_unordered<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<double,typename P_expr2::T_numtype> > >
+unordered(double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<double,P_numtype2> > >
+unordered(double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+    _bz_unordered<double,int> > >
+unordered(double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, Range,
+        _bz_unordered<double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<double,P_numtype2> > >
+unordered(double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<double>(d1), d2.beginFast()));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+    _bz_unordered<long double,P_numtype2> > >
+unordered(long double d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorIterConst<P_numtype2>,
+        _bz_unordered<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+    _bz_unordered<long double,typename P_expr2::T_numtype> > >
+unordered(long double d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, _bz_VecExpr<P_expr2>,
+        _bz_unordered<long double,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+    _bz_unordered<long double,P_numtype2> > >
+unordered(long double d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, VectorPickIterConst<P_numtype2>,
+        _bz_unordered<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+    _bz_unordered<long double,int> > >
+unordered(long double d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, Range,
+        _bz_unordered<long double,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2));
+}
+
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<long double,P_numtype2> > >
+unordered(long double d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<long double>, TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<long double,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<long double>(d1), d2.beginFast()));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+    _bz_unordered<complex<T1> ,P_numtype2> > >
+unordered(complex<T1> d1, const Vector<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorIterConst<P_numtype2>,
+        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+    _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > >
+unordered(complex<T1> d1, _bz_VecExpr<P_expr2> d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , _bz_VecExpr<P_expr2>,
+        _bz_unordered<complex<T1> ,typename P_expr2::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+    _bz_unordered<complex<T1> ,P_numtype2> > >
+unordered(complex<T1> d1, const VectorPick<P_numtype2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , VectorPickIterConst<P_numtype2>,
+        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+template<class T1>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+    _bz_unordered<complex<T1> ,int> > >
+unordered(complex<T1> d1, Range d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , Range,
+        _bz_unordered<complex<T1> ,int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2));
+}
+
+template<class T1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+    _bz_unordered<complex<T1> ,P_numtype2> > >
+unordered(complex<T1> d1, const TinyVector<P_numtype2, N_length2>& d2)
+{
+    typedef _bz_VecExprOp<_bz_VecExprConstant<complex<T1> > , TinyVectorIterConst<P_numtype2, N_length2>,
+        _bz_unordered<complex<T1> ,P_numtype2> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(_bz_VecExprConstant<complex<T1> > (d1), d2.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * y0
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_y0<P_numtype1> > >
+y0(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_y0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_y0<typename P_expr1::T_numtype> > >
+y0(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_y0<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_y0<P_numtype1> > >
+y0(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_y0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_y0<int> > >
+y0(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_y0<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_y0<P_numtype1> > >
+y0(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_y0<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+/****************************************************************************
+ * y1
+ ****************************************************************************/
+
+#ifdef BZ_HAVE_IEEE_MATH
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+    _bz_y1<P_numtype1> > >
+y1(const Vector<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorIterConst<P_numtype1>,
+        _bz_y1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+    _bz_y1<typename P_expr1::T_numtype> > >
+y1(_bz_VecExpr<P_expr1> d1)
+{
+    typedef _bz_VecExprUnaryOp<_bz_VecExpr<P_expr1>,
+        _bz_y1<typename P_expr1::T_numtype> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+    _bz_y1<P_numtype1> > >
+y1(const VectorPick<P_numtype1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<VectorPickIterConst<P_numtype1>,
+        _bz_y1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<Range,
+    _bz_y1<int> > >
+y1(Range d1)
+{
+    typedef _bz_VecExprUnaryOp<Range,
+        _bz_y1<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1));
+}
+
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+    _bz_y1<P_numtype1> > >
+y1(const TinyVector<P_numtype1, N_length1>& d1)
+{
+    typedef _bz_VecExprUnaryOp<TinyVectorIterConst<P_numtype1, N_length1>,
+        _bz_y1<P_numtype1> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast()));
+}
+
+#endif
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/vecwhere.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/vecwhere.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecwhere.cc	(revision 73)
@@ -0,0 +1,7744 @@
+/***************************************************************************
+ * blitz/../vecwhere.cc	where(X,Y,Z) function for vectors
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-suggest@cybervision.com
+ * Bugs:                 blitz-bugs@cybervision.com
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://seurat.uwaterloo.ca/blitz/
+ *
+ ***************************************************************************
+ *
+ */ 
+
+// Generated source file.  Do not edit. 
+// genvecwhere.cpp Oct  6 2005 15:58:49
+
+#ifndef BZ_VECWHERE_CC
+#define BZ_VECWHERE_CC
+
+BZ_NAMESPACE(blitz)
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, Range)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, int)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, float)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, long double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, Vector<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, Range)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_expr2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, int)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, float)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, double)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, long double)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, _bz_VecExpr<P_expr2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_expr2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, Range)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, int)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, float)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, long double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, VectorPick<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, Range, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Range, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(Vector<P_numtype1>, Range, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Range, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(Vector<P_numtype1>, Range, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, Range, int)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, Range, float)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, Range, double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, Range, long double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, Range, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      Range d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, Range)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, int)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, float)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, double)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, long double)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, int N_length2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, int, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, int, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, int, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, int, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, int, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, int, int)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > >
+where(const Vector<P_numtype1>& d1, 
+      int d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Vector<P_numtype1>, float, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, float, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, float, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, float, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, float, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, float, float)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > >
+where(const Vector<P_numtype1>& d1, 
+      float d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Vector<P_numtype1>, double, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, double, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, double, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, double, double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > >
+where(const Vector<P_numtype1>& d1, 
+      double d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Vector<P_numtype1>, long double, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, long double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, long double, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, long double, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(Vector<P_numtype1>, long double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Vector<P_numtype1>, long double, long double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > >
+where(const Vector<P_numtype1>& d1, 
+      long double d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Vector<P_numtype1>, complex<T2>, Vector<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, complex<T2>, _bz_VecExpr<P_expr3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, complex<T2>, VectorPick<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, complex<T2>, Range)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Vector<P_numtype1>, complex<T2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const Vector<P_numtype1>& d1, 
+      complex<T2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, Range)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, int)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, float)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, double)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, long double)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Vector<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const Vector<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
+template<class P_expr1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
+template<class P_expr1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, Range)
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_expr2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, int)
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, float)
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, double)
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, long double)
+template<class P_expr1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, _bz_VecExpr<P_expr2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class P_expr2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, Range)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, int)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, float)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, double)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, long double)
+template<class P_expr1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, VectorPick<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const VectorPick<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, Range, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, Range)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, int)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, float)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, double)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, long double)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, Range, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      Range d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_numtype2, int N_length2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, Range)
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, int)
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, float)
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, double)
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, long double)
+template<class P_expr1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class P_numtype2, int N_length2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, int, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, int, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, int, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, int, Range)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, int, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, int, int)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      int d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, Range)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, float, float)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      float d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, Range)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, double, double)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      double d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, Vector<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, _bz_VecExpr<P_expr3>)
+template<class P_expr1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, VectorPick<P_numtype3>)
+template<class P_expr1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, Range)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, TinyVector<P_numtype3, N_length3>)
+template<class P_expr1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(_bz_VecExpr<P_expr1>, long double, long double)
+template<class P_expr1>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      long double d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, Vector<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, _bz_VecExpr<P_expr3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, VectorPick<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, Range)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(_bz_VecExpr<P_expr1>, complex<T2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr1, class T2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(_bz_VecExpr<P_expr1> d1, 
+      complex<T2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<_bz_VecExpr<P_expr1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, Range)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, int)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, float)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, long double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Vector<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, Range)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_expr2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, int)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, float)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, double)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, long double)
+template<class P_numtype1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, _bz_VecExpr<P_expr2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_expr2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, Range)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, int)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, float)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, long double)
+template<class P_numtype1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, VectorPick<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, Range, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Range, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, Range, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Range, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, Range, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, Range, int)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Range, float)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Range, double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Range, long double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, Range, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      Range d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, Range)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, int)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, float)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, double)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, long double)
+template<class P_numtype1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class P_numtype2, int N_length2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, int, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, int, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, int, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, int, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, int, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, int, int)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > >
+where(const VectorPick<P_numtype1>& d1, 
+      int d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, float, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, float, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, float, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, float, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, float, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, float, float)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > >
+where(const VectorPick<P_numtype1>& d1, 
+      float d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, double, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, double, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, double, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, double, double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      double d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, long double, Vector<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, long double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, long double, VectorPick<P_numtype3>)
+template<class P_numtype1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, long double, Range)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(VectorPick<P_numtype1>, long double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(VectorPick<P_numtype1>, long double, long double)
+template<class P_numtype1>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > >
+where(const VectorPick<P_numtype1>& d1, 
+      long double d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(VectorPick<P_numtype1>, complex<T2>, Vector<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, complex<T2>, _bz_VecExpr<P_expr3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, complex<T2>, VectorPick<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, complex<T2>, Range)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(VectorPick<P_numtype1>, complex<T2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, class T2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const VectorPick<P_numtype1>& d1, 
+      complex<T2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<VectorPickIterConst<P_numtype1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, Vector<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, Vector<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, Vector<P_numtype2>, Range)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      Range > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, Vector<P_numtype2>, int)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, Vector<P_numtype2>, float)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, Vector<P_numtype2>, double)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, Vector<P_numtype2>, long double)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, Vector<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      const Vector<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
+template<class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
+template<class P_expr2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
+template<class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, Range)
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      Range > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
+template<class P_expr2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, int)
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, float)
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, double)
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, long double)
+template<class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, _bz_VecExpr<P_expr2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_expr2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, VectorPick<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, VectorPick<P_numtype2>, Range)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, VectorPick<P_numtype2>, int)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, VectorPick<P_numtype2>, float)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, VectorPick<P_numtype2>, double)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, VectorPick<P_numtype2>, long double)
+template<class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, VectorPick<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      const VectorPick<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, Range, Vector<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      Range d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, Range, _bz_VecExpr<P_expr3>)
+template<class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      Range d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(Range, Range, VectorPick<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      Range d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, Range, Range)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      Range > >
+where(Range d1, 
+      Range d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3));
+}
+
+// where(Range, Range, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      Range d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(Range, Range, int)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      Range d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, Range, float)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      Range d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, Range, double)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      Range d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, Range, long double)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      Range d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, Range, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      Range d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
+template<class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype2, int N_length2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
+template<class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, Range)
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype2, int N_length2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, int)
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, float)
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, double)
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, long double)
+template<class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, TinyVector<P_numtype2, N_length2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype2, int N_length2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, int, Vector<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      int d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, int, _bz_VecExpr<P_expr3>)
+template<class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      int d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(Range, int, VectorPick<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      int d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, int, Range)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      Range > >
+where(Range d1, 
+      int d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(Range, int, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      int d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, int, int)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > >
+where(Range d1, 
+      int d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<int>(d2), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(Range, float, Vector<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      float d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, float, _bz_VecExpr<P_expr3>)
+template<class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      float d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(Range, float, VectorPick<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      float d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, float, Range)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      Range > >
+where(Range d1, 
+      float d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(Range, float, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      float d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, float, float)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > >
+where(Range d1, 
+      float d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<float>(d2), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(Range, double, Vector<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, double, _bz_VecExpr<P_expr3>)
+template<class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(Range, double, VectorPick<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, double, Range)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      Range > >
+where(Range d1, 
+      double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(Range, double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, double, double)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > >
+where(Range d1, 
+      double d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<double>(d2), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(Range, long double, Vector<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      long double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, long double, _bz_VecExpr<P_expr3>)
+template<class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      long double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(Range, long double, VectorPick<P_numtype3>)
+template<class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      long double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, long double, Range)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      Range > >
+where(Range d1, 
+      long double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(Range, long double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      long double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(Range, long double, long double)
+
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > >
+where(Range d1, 
+      long double d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<long double>(d2), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(Range, complex<T2>, Vector<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > >
+where(Range d1, 
+      complex<T2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, complex<T2>, _bz_VecExpr<P_expr3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > >
+where(Range d1, 
+      complex<T2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, complex<T2>, VectorPick<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > >
+where(Range d1, 
+      complex<T2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, complex<T2>, Range)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > >
+where(Range d1, 
+      complex<T2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, complex<T2>, TinyVector<P_numtype3, N_length3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(Range d1, 
+      complex<T2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(Range, complex<T2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class T2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(Range d1, 
+      complex<T2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<Range, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1, 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, Range)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, int)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, float)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, double)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, long double)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Vector<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const Vector<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, Range)
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_expr2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, int)
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, float)
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, double)
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, long double)
+template<class P_numtype1, int N_length1, class P_expr2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, _bz_VecExpr<P_expr2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class P_expr2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      _bz_VecExpr<P_expr2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExpr<P_expr2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, Range)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, int)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, float)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, double)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, long double)
+template<class P_numtype1, int N_length1, class P_numtype2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, VectorPick<P_numtype2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class P_numtype2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const VectorPick<P_numtype2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      VectorPickIterConst<P_numtype2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, Range, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, Range)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, int)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, float)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, double)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, long double)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, Range, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      Range d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      Range, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2, 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, Range)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, int)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, float)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, double)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, long double)
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, TinyVector<P_numtype2, N_length2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class P_numtype2, int N_length2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      const TinyVector<P_numtype2, N_length2>& d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      TinyVectorIterConst<P_numtype2, N_length2>, 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      d2.beginFast(), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, int, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, int, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, int, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, int, Range)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, int, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, int, int)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      int d2, 
+      int d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<int>, 
+      _bz_VecExprConstant<int> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<int>(d2), 
+      _bz_VecExprConstant<int>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, Range)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, float, float)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      float d2, 
+      float d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<float>, 
+      _bz_VecExprConstant<float> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<float>(d2), 
+      _bz_VecExprConstant<float>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, Range)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, double, double)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      double d2, 
+      double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<double>, 
+      _bz_VecExprConstant<double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<double>(d2), 
+      _bz_VecExprConstant<double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, Vector<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, _bz_VecExpr<P_expr3>)
+template<class P_numtype1, int N_length1, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, VectorPick<P_numtype3>)
+template<class P_numtype1, int N_length1, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, Range)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, TinyVector<P_numtype3, N_length3>)
+template<class P_numtype1, int N_length1, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      d3.beginFast()));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, long double, long double)
+template<class P_numtype1, int N_length1>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      long double d2, 
+      long double d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<long double>, 
+      _bz_VecExprConstant<long double> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<long double>(d2), 
+      _bz_VecExprConstant<long double>(d3)));
+}
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, Vector<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      const Vector<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, _bz_VecExpr<P_expr3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2, class P_expr3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      _bz_VecExpr<P_expr3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExpr<P_expr3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, VectorPick<P_numtype3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2, class P_numtype3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      const VectorPick<P_numtype3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      VectorPickIterConst<P_numtype3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, Range)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      Range d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      Range > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, TinyVector<P_numtype3, N_length3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2, class P_numtype3, int N_length3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      const TinyVector<P_numtype3, N_length3>& d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      TinyVectorIterConst<P_numtype3, N_length3> > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      d3.beginFast()));
+}
+#endif // BZ_HAVE_COMPLEX
+
+// where(TinyVector<P_numtype1, N_length1>, complex<T2>, complex<T3>)
+#ifdef BZ_HAVE_COMPLEX
+template<class P_numtype1, int N_length1, class T2, class T3>
+inline
+_bz_VecExpr<_bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > >
+where(const TinyVector<P_numtype1, N_length1>& d1, 
+      complex<T2> d2, 
+      complex<T3> d3)
+{ 
+    typedef _bz_VecWhere<TinyVectorIterConst<P_numtype1, N_length1>, 
+      _bz_VecExprConstant<complex<T2> > , 
+      _bz_VecExprConstant<complex<T3> >  > T_expr;
+
+    return _bz_VecExpr<T_expr>(T_expr(d1.beginFast(), 
+      _bz_VecExprConstant<complex<T2> > (d2), 
+      _bz_VecExprConstant<complex<T3> > (d3)));
+}
+#endif // BZ_HAVE_COMPLEX
+
+BZ_NAMESPACE_END
+
+#endif
Index: /XMLIO_V2/external/include/blitz/vecwhere.h
===================================================================
--- /XMLIO_V2/external/include/blitz/vecwhere.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/vecwhere.h	(revision 73)
@@ -0,0 +1,120 @@
+// -*- C++ -*-
+/***************************************************************************
+ * blitz/vecwhere.h      where(X,Y,Z) function for vectors
+ *
+ * $Id: vecwhere.h,v 1.5 2005/05/07 04:17:56 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ****************************************************************************/
+
+#ifndef BZ_VECWHERE_H 
+#define BZ_VECWHERE_H
+
+#ifndef BZ_VECEXPR_H
+ #error <blitz/vecwhere.h> must be included via <blitz/vector.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_expr1, typename P_expr2, typename P_expr3>
+class _bz_VecWhere {
+
+public:
+    typedef P_expr1 T_expr1;
+    typedef P_expr2 T_expr2;
+    typedef P_expr3 T_expr3;
+    typedef _bz_typename T_expr2::T_numtype T_numtype2;
+    typedef _bz_typename T_expr3::T_numtype T_numtype3;
+    typedef BZ_PROMOTE(T_numtype2, T_numtype3) T_numtype;
+
+#ifdef BZ_PASS_EXPR_BY_VALUE
+    _bz_VecWhere(T_expr1 a, T_expr2 b, T_expr3 c)
+        : iter1_(a), iter2_(b), iter3_(c)
+    { }
+#else
+    _bz_VecWhere(const T_expr1& a, const T_expr2& b, const T_expr3& c)
+        : iter1_(a), iter2_(b), iter3_(c)
+    { }
+#endif
+
+#ifdef BZ_MANUAL_VECEXPR_COPY_CONSTRUCTOR
+    _bz_VecWhere(const _bz_VecWhere<T_expr1, T_expr2, T_expr3>& x)
+        : iter1_(x.iter1_), iter2_(x.iter2_), iter3_(x.iter3_)
+    { }
+#endif
+
+    T_numtype operator[](int i) const
+    { 
+        return iter1_[i] ? iter2_[i] : iter3_[i];
+    }
+
+    static const int
+        _bz_staticLengthCount = P_expr1::_bz_staticLengthCount
+                              + P_expr2::_bz_staticLengthCount
+                              + P_expr3::_bz_staticLengthCount,
+        _bz_dynamicLengthCount = P_expr1::_bz_dynamicLengthCount
+                               + P_expr2::_bz_dynamicLengthCount
+                               + P_expr3::_bz_dynamicLengthCount,
+        _bz_staticLength =
+            _bz_meta_max<_bz_meta_max<P_expr1::_bz_staticLength, 
+            P_expr2::_bz_staticLength>::max, P_expr3::_bz_staticLength>::max;
+
+    T_numtype _bz_fastAccess(int i) const
+    { 
+        return iter1_._bz_fastAccess(i) 
+            ? iter2_._bz_fastAccess(i) 
+            : iter3_._bz_fastAccess(i); 
+    }
+
+    bool _bz_hasFastAccess() const
+    {
+        return iter1_._bz_hasFastAccess() &&
+            iter2_._bz_hasFastAccess() &&
+            iter3_._bz_hasFastAccess();
+    }
+
+    int length(int recommendedLength) const
+    {
+        return iter1_.length(recommendedLength);
+    }
+
+    int _bz_suggestLength() const
+    {
+        BZPRECONDITION(
+            (iter1_._bz_suggestLength() == iter2_._bz_suggestLength())
+         && (iter2_._bz_suggestLength() == iter3_._bz_suggestLength()));
+
+        return iter1_._bz_suggestLength();
+    }
+
+private:
+    _bz_VecWhere() { }
+
+    T_expr1 iter1_;
+    T_expr2 iter2_;
+    T_expr3 iter3_;
+};
+
+BZ_NAMESPACE_END
+
+#include <blitz/vecwhere.cc>        // Expression templates
+
+#endif // BZ_VECWHERE_H
+
Index: /XMLIO_V2/external/include/blitz/wrap-climits.h
===================================================================
--- /XMLIO_V2/external/include/blitz/wrap-climits.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/wrap-climits.h	(revision 73)
@@ -0,0 +1,10 @@
+#ifndef BZ_WRAP_CLIMITS_H
+#define BZ_WRAP_CLIMITS_H
+
+#ifdef BZ_HAVE_CLIMITS
+ #include <climits>
+#else
+ #include <limits.h>
+#endif
+
+#endif
Index: /XMLIO_V2/external/include/blitz/zero.cc
===================================================================
--- /XMLIO_V2/external/include/blitz/zero.cc	(revision 73)
+++ /XMLIO_V2/external/include/blitz/zero.cc	(revision 73)
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 1997 Todd Veldhuizen <tveldhui@oonumerics.org>
+ * All rights reserved.  Please see <blitz/blitz.h> for terms and
+ * conditions of use.
+ *
+ */
+
+#ifndef BZ_ZERO_H
+ #include <blitz/zero.h>
+#endif
+
+#ifndef BZ_ZERO_CC
+#define BZ_ZERO_CC
+
+BZ_NAMESPACE(blitz)
+
+#ifdef BZ_HAVE_COMPLEX
+
+complex<float>  ZeroElement<complex<float> >::zero_ = 
+    complex<float>(0.0f, 0.0f);
+
+complex<double> ZeroElement<complex<double> >::zero_ =
+    complex<double>(0.,0.);
+
+complex<long double> ZeroElement<complex<long double> >::zero_ =
+    complex<long double>(0.0L, 0.0L);
+
+#endif // BZ_HAVE_COMPLEX
+
+BZ_NAMESPACE_END
+
+#endif // BZ_ZERO_CC
+
Index: /XMLIO_V2/external/include/blitz/zero.h
===================================================================
--- /XMLIO_V2/external/include/blitz/zero.h	(revision 73)
+++ /XMLIO_V2/external/include/blitz/zero.h	(revision 73)
@@ -0,0 +1,104 @@
+/***************************************************************************
+ * blitz/zero.h          Zero elements
+ *
+ * $Id: zero.h,v 1.5 2003/12/11 03:44:22 julianc Exp $
+ *
+ * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-dev@oonumerics.org
+ * Bugs:                 blitz-bugs@oonumerics.org
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://oonumerics.org/blitz/
+ *
+ ***************************************************************************/
+
+/*
+ * The purpose of the ZeroElement class is to provide an lvalue for
+ * non-const element access of matrices with zero elements.  For
+ * example, a tridiagonal matrix has many elements which are
+ * always zero:
+ *
+ * [ x x 0 0 ]
+ * [ x x x 0 ]
+ * [ 0 x x x ]
+ * [ 0 0 x x ]
+ *
+ * To implement an operator()(int i, int j) for a tridiagonal
+ * matrix which may be used as an lvalue
+ *
+ * e.g. Matrix<double, Tridiagonal> M(4,4);
+ *      M(1,2) = 3.0L;
+ *
+ * some way of returning an lvalue for the zero elements is needed.
+ * (Either that, or an intermediate class must be returned -- but
+ * this is less efficient).  The solution used for the Blitz++
+ * library is to have a unique zero element for each numeric
+ * type (float, double, etc.).  This zero element is then
+ * returned as an lvalue when needed.
+ *
+ * The disadvantage is the possibility of setting the global
+ * zero-element to something non-zero.  
+ */
+
+#ifndef BZ_ZERO_H
+#define BZ_ZERO_H
+
+#ifndef BZ_BLITZ_H
+ #include <blitz/blitz.h>
+#endif
+
+BZ_NAMESPACE(blitz)
+
+template<typename P_numtype>
+class ZeroElement {
+public:
+    typedef P_numtype T_numtype;
+
+    static T_numtype& zero()
+    { 
+        return zero_; 
+    }
+
+private:
+    static T_numtype zero_;
+};
+
+// Specialization of ZeroElement for complex<float>, complex<double>,
+// and complex<long double>
+
+#define BZZERO_DECLARE(T)            \
+  template<>                         \
+  class ZeroElement<T > {            \
+  public:                            \
+    static T& zero()                 \
+    { return zero_; }                \
+  private:                           \
+    static T zero_;                  \
+  }
+
+#ifdef BZ_HAVE_COMPLEX
+  BZZERO_DECLARE(complex<float>);
+  BZZERO_DECLARE(complex<double>);
+  BZZERO_DECLARE(complex<long double>);
+#endif // BZ_HAVE_COMPLEX
+
+// initialization of static data member for general class template
+
+template<typename P_numtype>
+P_numtype ZeroElement<P_numtype>::zero_ = 0;
+
+BZ_NAMESPACE_END
+
+#endif // BZ_ZERO_H
+
