[libc++] Provide additional templates for valarray transcendentals that satisfy the standard synopsis

[petpav01]

Summary

Libc++ provides valarray transcendentals with replacement types. These functions are implemented either as template<class _Expr> or template<class _Expr1, class _Expr2>, where _Expr can be __val_expr or valarray.

The patch provides additional function templates for valarray transcendentals that as a parameter use _Tp which is a type of elements in the valarray. This is required by the standard and is needed if the user tries to explicitly instantiate the transcendental functions using _Tp, for example, std::abs<int>(int_valarray).

New templates do not take an additional _Expr parameter and so the functions accept only valarray as their parameter. This means that if the user explicitly instantiates these function templates and passes __val_expr to them, it first needs to be converted to valarray and the benefit of the expression template optimization is not present. No performance is lost in the currently possible case where template parameters are deduced because using __val_expr as an argument will lead to instantiation of the already present templates.

[petpav01]

It would be probably better if the patch changed the original templates to take only __val_expr as there is now no need for them to match valarray too. This should be a simple change but requires additional tests so I will wait for initial feedback that this approach is preferred.

[EricWF]

This is required by the standard and is needed if the user tries to explicitly instantiate the transcendental functions using _Tp, for example, std::abs<int>(int_valarray).

These may in fact be required by the standard but not for the reason you say. The standard essentially prohibits users from doing anything with standard library functions other than calling them with a list of arguments. This includes specifying default template parameters. The relevant text from the current C++ draft:

[17.6.5.4] global.functions`

2. A call to a global or non-member function signature described in Clauses 18 through 30 and Annex D shall

behave as if the implementation declared no additional global or non-member function signatures

However the overloads you need are required for standard conformance because they provide an interface that requires an implicit conversion to valarray<Tp> be performed. This subtly changes its ranking in overload resolution. For this reason we need this patch.

At first look this patch looks good, and it adds lots of tests which is even better.

[EricWF]

One thing does need to change though. For each overload you added you need to change all of the uses of __is_val_expr in the original overload to a new metafunction that only accepts __val_expr templates and not valarray.

I'm marking as "changes requested" so phabricator properly bins this. Thanks again for the patch.

[petpav01]

Thank you for having a look at this patch. I should get to updating it as requested soon. Apologies for the delay.

[petpav01]

I am not sure if I understand the comment about [17.6.5.4] correctly. It is not clear to me how this part of the standard prevents the user from specifying explicit template parameters for standard functions. It seems odd that the standard would disallow, for example, to use std::max<double>(1, 2.0).

New patch changes the transcendentals that accepted any Expr (i.e. valarray or __val_expr) to only accept __val_expr. In two cases (atan2() and pow()) the original template had to be split into four functions:

• func(const __val_expr&, const __val_expr&)
• func(const __val_expr&, const valarray&)
• func(const valarray&, const __val_expr&)
• func(const valarray&, const valarray&)

is_same checks on value_type of both operands are also added in these cases.

Missing thing is a better test coverage. The tests currently do not instantiate the __val_expr templates. I am working on this. Could you please send me an example that shows the problem with the ranking in overload resolution so I can add a test for it too?

[petpav01]

Updated patch adds more tests and fixes a problem introduced in the previous revision where templates taking __val_expr were not correctly protected by SFINAE from immediate context (it introduced same problem with explicit template parameters that I am trying to solve).

@Eric: Could you please send me an example that shows the problem with the ranking in overload resolution so I can add a test for it too? I would like to understand this case because if it is not needed then a number of atan2() and pow() templates can be reduced (to the same amount as in the original patch).

[petpav01]

Ping. I would still like to address this problem. Could I please get a review on the last version of the patch?

Thanks,
Petr

[jasonliu]

Ping.
Any review for this patch? It would be great if we can get this issue fixed.

[EricWF]

wow this is old. I'll try and re-review before the new year.

[petpav01]

Patch rebased.

[rmaprath]

I've raised PR31966 to poke this :)

include/valarray

 struct __is_val_expr : false_type {};
 
 template<class _ValExpr>
 struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
 
 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_TYPE_VIS_ONLY valarray
 {
 public:
     typedef _Tp value_type;
     typedef _Tp result_type;
 
 private:
operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
     return __val_expr<_Op>(_Op(greater_equal<value_type>(),
                            __scalar_expr<value_type>(__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<__abs_expr<typename _Expr::value_type>, _Expr> >
 >::type
 abs(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
     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
 atan2(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
                            __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
 atan2(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
                            __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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
     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
 pow(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
                            __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
 pow(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
                            __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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
     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)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
 }
 
-template <class _Tp>
+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*
 begin(valarray<_Tp>& __v)
 {
     return __v.__begin_;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp

 //   valarray<T>
 //   abs(const valarray<T>& x);
 
 #include <valarray>
 #include <cassert>
 
 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]);
+    {
+        // abs(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = abs(v1);
         assert(v3.size() == v1.size());
         for (int 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]);
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // acos(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = acos(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // asin(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = asin(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // atan2(valarray&, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<T> v3 = atan2(v1, v2);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // atan2(valarray&, T)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan2(v1, .75);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // atan2(T, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan2(.75, v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // atan(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = atan(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // cos(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = cos(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // cosh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = cosh(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // exp(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = exp(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // log10(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = log10(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // log(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = log(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // pow(valarray&, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<T> v3 = pow(v1, v2);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // pow(valarray&, T)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = pow(v1, 2.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&, 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // pow(T, valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = pow(2.0, v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // sin(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sin(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // sinh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sinh(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // sqrt(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = sqrt(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // tan(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = tan(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }

test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp

bool is_about(double x, double y, int p)
     std::string a = o.str();
     o.str("");
     o << y;
     return a == o.str();
 }
 
 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]);
+    {
+        // tanh(valarray&)
         std::valarray<T> v1(a1, N);
         std::valarray<T> v3 = tanh(v1);
         assert(v3.size() == v1.size());
         for (int 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));
+    }
 }