From: Jonathan Wakely Date: Thu, 18 Oct 2018 15:38:50 +0000 (+0100) Subject: PR libstdc++/87641 correctly initialize accumulator in valarray::sum() X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=fab2c75b73c11d5c6d652a20bfa34e1733f1407f;p=gcc.git PR libstdc++/87641 correctly initialize accumulator in valarray::sum() Use the value of the first element as the initial value of the __valarray_sum accumulator. Value-initialization might not create the additive identity for the value type. Make a similar change to __valarray_product even though it's only ever used internally with a value_type of size_t. PR libstdc++/87641 * include/bits/valarray_array.h (__valarray_sum): Use first element to initialize accumulator instead of value-initializing it. (__valarray_product<_Tp>): Move to ... * src/c++98/valarray.cc (__valarray_product<_Tp>): Here. Use first element to initialize accumulator. (__valarray_product(const valarray&)): Remove const_cast made unnecessary by LWG 389. * testsuite/26_numerics/valarray/87641.cc: New test. From-SVN: r265270 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 426c7d8b29c..cb9aac1a7c3 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,15 @@ +2018-10-18 Jonathan Wakely + + PR libstdc++/87641 + * include/bits/valarray_array.h (__valarray_sum): Use first element + to initialize accumulator instead of value-initializing it. + (__valarray_product<_Tp>): Move to ... + * src/c++98/valarray.cc (__valarray_product<_Tp>): Here. Use first + element to initialize accumulator. + (__valarray_product(const valarray&)): Remove const_cast made + unnecessary by LWG 389. + * testsuite/26_numerics/valarray/87641.cc: New test. + 2018-10-18 François Dumont Partial revert. diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h index 6759d6003e9..2dd1ec836ac 100644 --- a/libstdc++-v3/include/bits/valarray_array.h +++ b/libstdc++-v3/include/bits/valarray_array.h @@ -338,33 +338,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } // - // Compute the sum of elements in range [__f, __l) + // Compute the sum of elements in range [__f, __l) which must not be empty. // This is a naive algorithm. It suffers from cancelling. - // In the future try to specialize - // for _Tp = float, double, long double using a more accurate - // algorithm. + // In the future try to specialize for _Tp = float, double, long double + // using a more accurate algorithm. // template inline _Tp __valarray_sum(const _Tp* __f, const _Tp* __l) { - _Tp __r = _Tp(); + _Tp __r = *__f++; while (__f != __l) __r += *__f++; return __r; } - // Compute the product of all elements in range [__f, __l) - template - inline _Tp - __valarray_product(const _Tp* __f, const _Tp* __l) - { - _Tp __r = _Tp(1); - while (__f != __l) - __r = __r * *__f++; - return __r; - } - // Compute the min/max of an array-expression template inline typename _Ta::value_type diff --git a/libstdc++-v3/src/c++98/valarray.cc b/libstdc++-v3/src/c++98/valarray.cc index 3cec1843be2..284db21e81c 100644 --- a/libstdc++-v3/src/c++98/valarray.cc +++ b/libstdc++-v3/src/c++98/valarray.cc @@ -45,15 +45,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template size_t valarray::size() const; template size_t& valarray::operator[](size_t); + // Compute the product of all elements in the non-empty range [__f, __l) + template + inline _Tp + __valarray_product(const _Tp* __f, const _Tp* __l) + { + _Tp __r = *__f++; + while (__f != __l) + __r = __r * *__f++; + return __r; + } + inline size_t __valarray_product(const valarray& __a) { - const size_t __n = __a.size(); - // XXX: This ugly cast is necessary because - // valarray::operator[]() const return a VALUE! - // Try to get the committee to correct that gross error. - valarray& __t = const_cast&>(__a); - return __valarray_product(&__t[0], &__t[0] + __n); + return __valarray_product(&__a[0], &__a[0] + __a.size()); } // Map a gslice, described by its multidimensional LENGTHS diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc b/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc new file mode 100644 index 00000000000..eae5440e60b --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/87641.cc @@ -0,0 +1,75 @@ +// Copyright (C) 2018 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +void +test01() +{ + // PR libstdc++/87641 + std::valarray v1(3); + v1[0] = 1; + v1[1] = 2; + v1[2] = 3; + std::valarray< std::valarray > v2(v1, 3); + std::valarray v3 = v2.sum(); + VERIFY( v3.size() == v1.size() ); + VERIFY( v3[0] == 3 ); + VERIFY( v3[1] == 6 ); + VERIFY( v3[2] == 9 ); +} + +struct X +{ + X() : val(1) { } + + X& operator+=(const X& x) { val += x.val; return *this; } + bool operator==(const X& x) { return val == x.val; } + + int val; +}; + +void +test02() +{ + std::valarray v1(1); + VERIFY( v1.sum() == v1[0] ); + + std::valarray v2(2); + VERIFY( v2.sum().val == 2 ); +} + +struct Y +{ + X& operator+=(const Y&) { throw 1; } +}; + +void +test03() +{ + std::valarray v1(1); + (void) v1.sum(); // no addition performed for a single element +} + +int +main() +{ + test01(); + test02(); + test03(); +}