Index: include/valarray
===================================================================
--- include/valarray
+++ include/valarray
@@ -786,6 +786,12 @@
 template<class _Tp>
 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
+template<class _ValExpr>
+struct __is_val_expr_only : false_type {};
+
+template<class _ValExpr>
+struct __is_val_expr_only<__val_expr<_ValExpr> > : true_type {};
+
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS valarray
 {
@@ -4559,7 +4565,7 @@
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
 >::type
 abs(const _Expr& __x)
@@ -4569,11 +4575,20 @@
     return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__abs_expr<_Tp>, valarray<_Tp> > >
+abs(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__abs_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__abs_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
 >::type
 acos(const _Expr& __x)
@@ -4583,11 +4598,20 @@
     return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__acos_expr<_Tp>, valarray<_Tp> > >
+acos(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__acos_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__acos_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
 >::type
 asin(const _Expr& __x)
@@ -4597,11 +4621,20 @@
     return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__asin_expr<_Tp>, valarray<_Tp> > >
+asin(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__asin_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__asin_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
 >::type
 atan(const _Expr& __x)
@@ -4611,11 +4644,21 @@
     return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__atan_expr<_Tp>, valarray<_Tp> > >
+atan(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__atan_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__atan_expr<_Tp>(), __x));
+}
+
 template<class _Expr1, class _Expr2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
+    __is_val_expr_only<_Expr1>::value && __is_val_expr_only<_Expr2>::value &&
+    is_same<typename _Expr1::value_type, typename _Expr2::value_type>::value,
     __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
 >::type
 atan2(const _Expr1& __x, const _Expr2& __y)
@@ -4625,11 +4668,48 @@
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
 }
 
+template<class _Expr, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    __is_val_expr_only<_Expr>::value &&
+    is_same<typename _Expr::value_type, _Tp>::value,
+    __val_expr<_BinaryOp<__atan2_expr<_Tp>, _Expr, valarray<_Tp> > >
+>::type
+atan2(const _Expr& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__atan2_expr<_Tp>, _Expr, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__atan2_expr<_Tp>(), __x, __y));
+}
+
+template<class _Tp, class _Expr>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    __is_val_expr_only<_Expr>::value &&
+    is_same<_Tp, typename _Expr::value_type>::value,
+    __val_expr<_BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, _Expr> >
+>::type
+atan2(const valarray<_Tp>& __x, const _Expr& __y)
+{
+    typedef _BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, _Expr> _Op;
+    return __val_expr<_Op>(_Op(__atan2_expr<_Tp>(), __x, __y));
+}
+
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, valarray<_Tp> > >
+atan2(const valarray<_Tp>& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__atan2_expr<_Tp>(), __x, __y));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
                _Expr, __scalar_expr<typename _Expr::value_type> > >
 >::type
@@ -4641,11 +4721,21 @@
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, __scalar_expr<_Tp> > >
+atan2(const valarray<_Tp>& __x, const _Tp& __y)
+{
+    typedef _BinaryOp<__atan2_expr<_Tp>, valarray<_Tp>, __scalar_expr<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__atan2_expr<_Tp>(),
+                           __x, __scalar_expr<_Tp>(__y, __x.size())));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
                __scalar_expr<typename _Expr::value_type>, _Expr> >
 >::type
@@ -4657,11 +4747,21 @@
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__atan2_expr<_Tp>, __scalar_expr<_Tp>, valarray<_Tp> > >
+atan2(const _Tp& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__atan2_expr<_Tp>, __scalar_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__atan2_expr<_Tp>(),
+                           __scalar_expr<_Tp>(__x, __y.size()), __y));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
 >::type
 cos(const _Expr& __x)
@@ -4671,11 +4771,20 @@
     return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__cos_expr<_Tp>, valarray<_Tp> > >
+cos(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__cos_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__cos_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
 >::type
 cosh(const _Expr& __x)
@@ -4685,11 +4794,20 @@
     return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__cosh_expr<_Tp>, valarray<_Tp> > >
+cosh(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__cosh_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__cosh_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
 >::type
 exp(const _Expr& __x)
@@ -4699,11 +4817,20 @@
     return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__exp_expr<_Tp>, valarray<_Tp> > >
+exp(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__exp_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__exp_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
 >::type
 log(const _Expr& __x)
@@ -4713,11 +4840,20 @@
     return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__log_expr<_Tp>, valarray<_Tp> > >
+log(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__log_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__log_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
 >::type
 log10(const _Expr& __x)
@@ -4727,11 +4863,21 @@
     return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__log10_expr<_Tp>, valarray<_Tp> > >
+log10(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__log10_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__log10_expr<_Tp>(), __x));
+}
+
 template<class _Expr1, class _Expr2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
+    __is_val_expr_only<_Expr1>::value && __is_val_expr_only<_Expr2>::value &&
+    is_same<typename _Expr1::value_type, typename _Expr2::value_type>::value,
     __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
 >::type
 pow(const _Expr1& __x, const _Expr2& __y)
@@ -4741,11 +4887,48 @@
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
 }
 
+template<class _Expr, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    __is_val_expr_only<_Expr>::value &&
+    is_same<typename _Expr::value_type, _Tp>::value,
+    __val_expr<_BinaryOp<__pow_expr<_Tp>, _Expr, valarray<_Tp> > >
+>::type
+pow(const _Expr& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__pow_expr<_Tp>, _Expr, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__pow_expr<_Tp>(), __x, __y));
+}
+
+template<class _Tp, class _Expr>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    __is_val_expr_only<_Expr>::value &&
+    is_same<_Tp, typename _Expr::value_type>::value,
+    __val_expr<_BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, _Expr> >
+>::type
+pow(const valarray<_Tp>& __x, const _Expr& __y)
+{
+    typedef _BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, _Expr> _Op;
+    return __val_expr<_Op>(_Op(__pow_expr<_Tp>(), __x, __y));
+}
+
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, valarray<_Tp> > >
+pow(const valarray<_Tp>& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__pow_expr<_Tp>(), __x, __y));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
                _Expr, __scalar_expr<typename _Expr::value_type> > >
 >::type
@@ -4757,11 +4940,21 @@
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, __scalar_expr<_Tp> > >
+pow(const valarray<_Tp>& __x, const _Tp& __y)
+{
+    typedef _BinaryOp<__pow_expr<_Tp>, valarray<_Tp>, __scalar_expr<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__pow_expr<_Tp>(),
+                           __x, __scalar_expr<_Tp>(__y, __x.size())));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
                __scalar_expr<typename _Expr::value_type>, _Expr> >
 >::type
@@ -4773,11 +4966,21 @@
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_BinaryOp<__pow_expr<_Tp>, __scalar_expr<_Tp>, valarray<_Tp> > >
+pow(const _Tp& __x, const valarray<_Tp>& __y)
+{
+    typedef _BinaryOp<__pow_expr<_Tp>, __scalar_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__pow_expr<_Tp>(),
+                           __scalar_expr<_Tp>(__x, __y.size()), __y));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
 >::type
 sin(const _Expr& __x)
@@ -4787,11 +4990,20 @@
     return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__sin_expr<_Tp>, valarray<_Tp> > >
+sin(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__sin_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__sin_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
 >::type
 sinh(const _Expr& __x)
@@ -4801,11 +5013,20 @@
     return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__sinh_expr<_Tp>, valarray<_Tp> > >
+sinh(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__sinh_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__sinh_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
 >::type
 sqrt(const _Expr& __x)
@@ -4815,11 +5036,19 @@
     return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__sqrt_expr<_Tp>, valarray<_Tp> > >
+sqrt(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__sqrt_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__sqrt_expr<_Tp>(), __x));
+}
+
+template<class _Expr>
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
 >::type
 tan(const _Expr& __x)
@@ -4829,11 +5058,20 @@
     return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__tan_expr<_Tp>, valarray<_Tp> > >
+tan(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__tan_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__tan_expr<_Tp>(), __x));
+}
+
 template<class _Expr>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    __is_val_expr<_Expr>::value,
+    __is_val_expr_only<_Expr>::value,
     __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
 >::type
 tanh(const _Expr& __x)
@@ -4843,6 +5081,15 @@
     return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
 }
 
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__val_expr<_UnaryOp<__tanh_expr<_Tp>, valarray<_Tp> > >
+tanh(const valarray<_Tp>& __x)
+{
+    typedef _UnaryOp<__tanh_expr<_Tp>, valarray<_Tp> > _Op;
+    return __val_expr<_Op>(_Op(__tanh_expr<_Tp>(), __x));
+}
+
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp*
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
@@ -21,15 +21,32 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {1.5,  -2.5,  3.4,  -4.5,  -5.0};
+    T a3[] = {1.5,   2.5,  3.4,   4.5,   5.0};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {1.5,  -2.5,  3.4,  -4.5,  -5.0};
-        T a3[] = {1.5,   2.5,  3.4,   4.5,   5.0};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // abs(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = abs(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+    {
+        // abs(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = abs(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(v3[i] == a3[i]);
+    }
+    {
+        // abs<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::abs<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(v3[i] == a3[i]);
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {2.6905658417935308e+00,
+              2.0943951023931957e+00,
+              1.5707963267948966e+00,
+              1.0471975511965976e+00,
+              7.2273424781341566e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {2.6905658417935308e+00,
-                  2.0943951023931957e+00,
-                  1.5707963267948966e+00,
-                  1.0471975511965976e+00,
-                  7.2273424781341566e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // acos(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = acos(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // acos(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = acos(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // acos<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::acos<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-1.1197695149986342e+00,
+              -5.2359877559829882e-01,
+              0.0000000000000000e+00,
+              5.2359877559829882e-01,
+              8.4806207898148100e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-1.1197695149986342e+00,
-                  -5.2359877559829882e-01,
-                  0.0000000000000000e+00,
-                  5.2359877559829882e-01,
-                  8.4806207898148100e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // asin(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = asin(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // asin(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = asin(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // asin<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::asin<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
@@ -34,16 +34,17 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a2[] = {-.8,  .25, 0.375, -.5, .75};
+    T a3[] = {-2.2974386674766221e+00,
+              -1.1071487177940904e+00,
+               0.0000000000000000e+00,
+               2.3561944901923448e+00,
+               7.8539816339744828e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a2[] = {-.8,  .25, 0.375, -.5, .75};
-        T a3[] = {-2.2974386674766221e+00,
-                  -1.1071487177940904e+00,
-                   0.0000000000000000e+00,
-                   2.3561944901923448e+00,
-                   7.8539816339744828e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // atan2(valarray&, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<T> v3 = atan2(v1, v2);
@@ -51,4 +52,40 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // atan2(valarray&, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = atan2(v1, v2 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan2(__val_expr&, valarray&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = atan2(v1 + 0.0, v2);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan2(__val_expr&, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = atan2(v1 + 0.0, v2 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan2<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = std::atan2<T>(v1, v2);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-8.7605805059819342e-01,
+              -5.8800260354756750e-01,
+               0.0000000000000000e+00,
+               5.8800260354756750e-01,
+               7.8539816339744828e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-8.7605805059819342e-01,
-                  -5.8800260354756750e-01,
-                   0.0000000000000000e+00,
-                   5.8800260354756750e-01,
-                   7.8539816339744828e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // atan2(valarray&, T)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan2(v1, .75);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // atan2(__val_expr&, T)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = atan2(v1 + 0.0, .75);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan2<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::atan2<T>(v1, .75);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {2.4468543773930902e+00,
+              2.1587989303424640e+00,
+              1.5707963267948966e+00,
+              9.8279372324732905e-01,
+              7.8539816339744828e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {2.4468543773930902e+00,
-                  2.1587989303424640e+00,
-                  1.5707963267948966e+00,
-                  9.8279372324732905e-01,
-                  7.8539816339744828e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // atan2(T, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan2(.75, v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // atan2(T, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = atan2(.75, v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan2<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::atan2<T>(.75, v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-7.3281510178650666e-01,
+              -4.6364760900080615e-01,
+               0.0000000000000000e+00,
+               4.6364760900080615e-01,
+               6.4350110879328437e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-7.3281510178650666e-01,
-                  -4.6364760900080615e-01,
-                   0.0000000000000000e+00,
-                   4.6364760900080615e-01,
-                   6.4350110879328437e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // atan(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // atan(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = atan(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // atan<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::atan<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {6.2160996827066450e-01,
+              8.7758256189037276e-01,
+              1.0000000000000000e+00,
+              8.7758256189037276e-01,
+              7.3168886887382090e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {6.2160996827066450e-01,
-                  8.7758256189037276e-01,
-                  1.0000000000000000e+00,
-                  8.7758256189037276e-01,
-                  7.3168886887382090e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // cos(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = cos(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // cos(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = cos(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // cos<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::cos<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {1.4330863854487743e+00,
+              1.1276259652063807e+00,
+              1.0000000000000000e+00,
+              1.1276259652063807e+00,
+              1.2946832846768448e+00};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {1.4330863854487743e+00,
-                  1.1276259652063807e+00,
-                  1.0000000000000000e+00,
-                  1.1276259652063807e+00,
-                  1.2946832846768448e+00};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // cosh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = cosh(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // cosh(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = cosh(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // cosh<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::cosh<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {4.0656965974059911e-01,
+              6.0653065971263342e-01,
+              1.0000000000000000e+00,
+              1.6487212707001282e+00,
+              2.1170000166126748e+00};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {4.0656965974059911e-01,
-                  6.0653065971263342e-01,
-                  1.0000000000000000e+00,
-                  1.6487212707001282e+00,
-                  2.1170000166126748e+00};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // exp(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = exp(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // exp(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = exp(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // exp<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::exp<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.5, .75, 1, 3, 7};
+    T a3[] = {-3.0102999566398120e-01,
+              -1.2493873660829995e-01,
+               0.0000000000000000e+00,
+               4.7712125471966244e-01,
+               8.4509804001425681e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.5, .75, 1, 3, 7};
-        T a3[] = {-3.0102999566398120e-01,
-                  -1.2493873660829995e-01,
-                   0.0000000000000000e+00,
-                   4.7712125471966244e-01,
-                   8.4509804001425681e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // log10(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = log10(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // log10(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = log10(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // log10<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::log10<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.5, .75, 1, 3, 7};
+    T a3[] = {-6.9314718055994529e-01,
+              -2.8768207245178090e-01,
+               0.0000000000000000e+00,
+               1.0986122886681098e+00,
+               1.9459101490553132e+00};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.5, .75, 1, 3, 7};
-        T a3[] = {-6.9314718055994529e-01,
-                  -2.8768207245178090e-01,
-                   0.0000000000000000e+00,
-                   1.0986122886681098e+00,
-                   1.9459101490553132e+00};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // log(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = log(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // log(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = log(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // log<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::log<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
@@ -34,16 +34,17 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.9, .5, 0., .5, .75};
+    T a2[] = {-.8,  .25, 0.375, -.5, .75};
+    T a3[] = {1.0879426248455297e+00,
+              8.4089641525371450e-01,
+              0.0000000000000000e+00,
+              1.4142135623730949e+00,
+              8.0592744886765644e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.9, .5, 0., .5, .75};
-        T a2[] = {-.8,  .25, 0.375, -.5, .75};
-        T a3[] = {1.0879426248455297e+00,
-                  8.4089641525371450e-01,
-                  0.0000000000000000e+00,
-                  1.4142135623730949e+00,
-                  8.0592744886765644e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // pow(valarray&, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<T> v3 = pow(v1, v2);
@@ -51,4 +52,40 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // pow(valarray&, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = pow(v1, v2 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // pow(__val_expr&, valarray&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = pow(v1 + 0.0, v2);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // pow(__val_expr&, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = pow(v1 + 0.0, v2 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // pow<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v2(a2, N);
+        std::valarray<T> v3 = std::pow<T>(v1, v2);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.9, .5, 0., .5, .75};
+    T a3[] = {8.1000000000000005e-01,
+              2.5000000000000000e-01,
+              0.0000000000000000e+00,
+              2.5000000000000000e-01,
+              5.6250000000000000e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.9, .5, 0., .5, .75};
-        T a3[] = {8.1000000000000005e-01,
-                  2.5000000000000000e-01,
-                  0.0000000000000000e+00,
-                  2.5000000000000000e-01,
-                  5.6250000000000000e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // pow(valarray&, T)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = pow(v1, 2.0);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // pow(__val_expr&, T)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = pow(v1 + 0.0, 2.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // pow<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::pow<T>(v1, 2.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.9, .5, 0., .5, .75};
+    T a3[] = {1.8660659830736148e+00,
+              1.4142135623730951e+00,
+              1.0000000000000000e+00,
+              1.4142135623730951e+00,
+              1.6817928305074290e+00};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.9, .5, 0., .5, .75};
-        T a3[] = {1.8660659830736148e+00,
-                  1.4142135623730951e+00,
-                  1.0000000000000000e+00,
-                  1.4142135623730951e+00,
-                  1.6817928305074290e+00};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // pow(T, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = pow(2.0, v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // pow(T, __val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = pow(2.0, v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // pow<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::pow<T>(2.0, v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-7.8332690962748330e-01,
+              -4.7942553860420301e-01,
+               0.0000000000000000e+00,
+               4.7942553860420301e-01,
+               6.8163876002333423e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-7.8332690962748330e-01,
-                  -4.7942553860420301e-01,
-                   0.0000000000000000e+00,
-                   4.7942553860420301e-01,
-                   6.8163876002333423e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // sin(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sin(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // sin(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = sin(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // sin<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::sin<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-1.0265167257081753e+00,
+              -5.2109530549374738e-01,
+               0.0000000000000000e+00,
+               5.2109530549374738e-01,
+               8.2231673193582999e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-1.0265167257081753e+00,
-                  -5.2109530549374738e-01,
-                   0.0000000000000000e+00,
-                   5.2109530549374738e-01,
-                   8.2231673193582999e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // sinh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sinh(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // sinh(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = sinh(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // sinh<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::sinh<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {.5, .75, 1, 3, 7};
+    T a3[] = {7.0710678118654757e-01,
+              8.6602540378443860e-01,
+              1.0000000000000000e+00,
+              1.7320508075688772e+00,
+              2.6457513110645907e+00};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {.5, .75, 1, 3, 7};
-        T a3[] = {7.0710678118654757e-01,
-                  8.6602540378443860e-01,
-                  1.0000000000000000e+00,
-                  1.7320508075688772e+00,
-                  2.6457513110645907e+00};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // sqrt(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sqrt(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // sqrt(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = sqrt(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // sqrt<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::sqrt<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-1.2601582175503390e+00,
+              -5.4630248984379048e-01,
+               0.0000000000000000e+00,
+               5.4630248984379048e-01,
+               9.3159645994407259e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-1.2601582175503390e+00,
-                  -5.4630248984379048e-01,
-                   0.0000000000000000e+00,
-                   5.4630248984379048e-01,
-                   9.3159645994407259e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // tan(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = tan(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // tan(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = tan(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // tan<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::tan<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
@@ -34,19 +34,36 @@
 
 int main()
 {
+    typedef double T;
+    T a1[] = {-.9, -.5, 0., .5, .75};
+    T a3[] = {-7.1629787019902447e-01,
+              -4.6211715726000974e-01,
+               0.0000000000000000e+00,
+               4.6211715726000974e-01,
+               6.3514895238728730e-01};
+    const unsigned N = sizeof(a1)/sizeof(a1[0]);
     {
-        typedef double T;
-        T a1[] = {-.9, -.5, 0., .5, .75};
-        T a3[] = {-7.1629787019902447e-01,
-                  -4.6211715726000974e-01,
-                   0.0000000000000000e+00,
-                   4.6211715726000974e-01,
-                   6.3514895238728730e-01};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        // tanh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = tanh(v1);
         assert(v3.size() == v1.size());
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+    {
+        // tanh(__val_expr&)
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = tanh(v1 + 0.0);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
+    {
+        // tanh<T>()
+        std::valarray<T> v1(a1, N);
+        std::valarray<T> v3 = std::tanh<T>(v1);
+        assert(v3.size() == v1.size());
+        for (int i = 0; i < v3.size(); ++i)
+            assert(is_about(v3[i], a3[i], 10));
+    }
 }