URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [stl_numeric.h] - Blame information for rev 35

Details | Compare with Previous | View Log


// Numeric functions implementation -*- C++ -*-
 
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
// 2011 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.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.
 
/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */
 
/** @file bits/stl_numeric.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{numeric}
 */
 
#ifndef _STL_NUMERIC_H
#define _STL_NUMERIC_H 1
 
#include <bits/concept_check.h>
#include <debug/debug.h>
#include <bits/move.h> // For _GLIBCXX_MOVE
 
#if __cplusplus >= 201103L
 
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
  /**
   *  @brief  Create a range of sequentially increasing values.
   *
   *  For each element in the range @p [first,last) assigns @p value and
   *  increments @p value as if by @p ++value.
   *
   *  @param  __first  Start of range.
   *  @param  __last  End of range.
   *  @param  __value  Starting value.
   *  @return  Nothing.
   */
  template<typename _ForwardIterator, typename _Tp>
    void
    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
    {
      // concept requirements
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
                                  _ForwardIterator>)
      __glibcxx_function_requires(_ConvertibleConcept<_Tp,
            typename iterator_traits<_ForwardIterator>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);
 
      for (; __first != __last; ++__first)
        {
          *__first = __value;
          ++__value;
        }
    }
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
 
#endif
 
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_ALGO
 
  /**
   *  @brief  Accumulate values in a range.
   *
   *  Accumulates the values in the range [first,last) using operator+().  The
   *  initial value is @a init.  The values are processed in order.
   *
   *  @param  __first  Start of range.
   *  @param  __last  End of range.
   *  @param  __init  Starting value to add other values to.
   *  @return  The final sum.
   */
  template<typename _InputIterator, typename _Tp>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_requires_valid_range(__first, __last);
 
      for (; __first != __last; ++__first)
        __init = __init + *__first;
      return __init;
    }
 
  /**
   *  @brief  Accumulate values in a range with operation.
   *
   *  Accumulates the values in the range [first,last) using the function
   *  object @p __binary_op.  The initial value is @p __init.  The values are
   *  processed in order.
   *
   *  @param  __first  Start of range.
   *  @param  __last  End of range.
   *  @param  __init  Starting value to add other values to.
   *  @param  __binary_op  Function object to accumulate with.
   *  @return  The final sum.
   */
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
               _BinaryOperation __binary_op)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_requires_valid_range(__first, __last);
 
      for (; __first != __last; ++__first)
        __init = __binary_op(__init, *__first);
      return __init;
    }
 
  /**
   *  @brief  Compute inner product of two ranges.
   *
   *  Starting with an initial value of @p __init, multiplies successive
   *  elements from the two ranges and adds each product into the accumulated
   *  value using operator+().  The values in the ranges are processed in
   *  order.
   *
   *  @param  __first1  Start of range 1.
   *  @param  __last1  End of range 1.
   *  @param  __first2  Start of range 2.
   *  @param  __init  Starting value to add other values to.
   *  @return  The final inner product.
   */
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    inline _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_requires_valid_range(__first1, __last1);
 
      for (; __first1 != __last1; ++__first1, ++__first2)
        __init = __init + (*__first1 * *__first2);
      return __init;
    }
 
  /**
   *  @brief  Compute inner product of two ranges.
   *
   *  Starting with an initial value of @p __init, applies @p __binary_op2 to
   *  successive elements from the two ranges and accumulates each result into
   *  the accumulated value using @p __binary_op1.  The values in the ranges are
   *  processed in order.
   *
   *  @param  __first1  Start of range 1.
   *  @param  __last1  End of range 1.
   *  @param  __first2  Start of range 2.
   *  @param  __init  Starting value to add other values to.
   *  @param  __binary_op1  Function object to accumulate with.
   *  @param  __binary_op2  Function object to apply to pairs of input values.
   *  @return  The final inner product.
   */
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
           typename _BinaryOperation1, typename _BinaryOperation2>
    inline _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init,
                  _BinaryOperation1 __binary_op1,
                  _BinaryOperation2 __binary_op2)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_requires_valid_range(__first1, __last1);
 
      for (; __first1 != __last1; ++__first1, ++__first2)
        __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
      return __init;
    }
 
  /**
   *  @brief  Return list of partial sums
   *
   *  Accumulates the values in the range [first,last) using the @c + operator.
   *  As each successive input value is added into the total, that partial sum
   *  is written to @p __result.  Therefore, the first value in @p __result is
   *  the first value of the input, the second value in @p __result is the sum
   *  of the first and second input values, and so on.
   *
   *  @param  __first  Start of input range.
   *  @param  __last  End of input range.
   *  @param  __result  Output sum.
   *  @return  Iterator pointing just beyond the values written to __result.
   */
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
 
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
                                                         _ValueType>)
      __glibcxx_requires_valid_range(__first, __last);
 
      if (__first == __last)
        return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
        {
          __value = __value + *__first;
          *++__result = __value;
        }
      return ++__result;
    }
 
  /**
   *  @brief  Return list of partial sums
   *
   *  Accumulates the values in the range [first,last) using @p __binary_op.
   *  As each successive input value is added into the total, that partial sum
   *  is written to @p __result.  Therefore, the first value in @p __result is
   *  the first value of the input, the second value in @p __result is the sum
   *  of the first and second input values, and so on.
   *
   *  @param  __first  Start of input range.
   *  @param  __last  End of input range.
   *  @param  __result  Output sum.
   *  @param  __binary_op  Function object.
   *  @return  Iterator pointing just beyond the values written to __result.
   */
  template<typename _InputIterator, typename _OutputIterator,
           typename _BinaryOperation>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
 
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
                                                         _ValueType>)
      __glibcxx_requires_valid_range(__first, __last);
 
      if (__first == __last)
        return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
        {
          __value = __binary_op(__value, *__first);
          *++__result = __value;
        }
      return ++__result;
    }
 
  /**
   *  @brief  Return differences between adjacent values.
   *
   *  Computes the difference between adjacent values in the range
   *  [first,last) using operator-() and writes the result to @p __result.
   *
   *  @param  __first  Start of input range.
   *  @param  __last  End of input range.
   *  @param  __result  Output sums.
   *  @return  Iterator pointing just beyond the values written to result.
   *
   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
   *  DR 539. partial_sum and adjacent_difference should mention requirements
   */
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    adjacent_difference(_InputIterator __first,
                        _InputIterator __last, _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
 
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
                                                         _ValueType>)
      __glibcxx_requires_valid_range(__first, __last);
 
      if (__first == __last)
        return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
        {
          _ValueType __tmp = *__first;
          *++__result = __tmp - __value;
          __value = _GLIBCXX_MOVE(__tmp);
        }
      return ++__result;
    }
 
  /**
   *  @brief  Return differences between adjacent values.
   *
   *  Computes the difference between adjacent values in the range
   *  [__first,__last) using the function object @p __binary_op and writes the
   *  result to @p __result.
   *
   *  @param  __first  Start of input range.
   *  @param  __last  End of input range.
   *  @param  __result  Output sum.
   *  @param  __binary_op Function object.
   *  @return  Iterator pointing just beyond the values written to result.
   *
   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
   *  DR 539. partial_sum and adjacent_difference should mention requirements
   */
  template<typename _InputIterator, typename _OutputIterator,
           typename _BinaryOperation>
    _OutputIterator
    adjacent_difference(_InputIterator __first, _InputIterator __last,
                        _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
 
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
                                                         _ValueType>)
      __glibcxx_requires_valid_range(__first, __last);
 
      if (__first == __last)
        return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
        {
          _ValueType __tmp = *__first;
          *++__result = __binary_op(__tmp, __value);
          __value = _GLIBCXX_MOVE(__tmp);
        }
      return ++__result;
    }
 
_GLIBCXX_END_NAMESPACE_ALGO
} // namespace std
 
#endif /* _STL_NUMERIC_H */

Browse

Tools

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [stl_numeric.h] - Blame information for rev 35

Line No.	Rev	Author	Line
1	35	ultra_embe	`// Numeric functions implementation -- C++ --`
2
3			`// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,`
4			`// 2011 Free Software Foundation, Inc.`
5			`//`
6			`// This file is part of the GNU ISO C++ Library. This library is free`
7			`// software; you can redistribute it and/or modify it under the`
8			`// terms of the GNU General Public License as published by the`
9			`// Free Software Foundation; either version 3, or (at your option)`
10			`// any later version.`
11
12			`// This library is distributed in the hope that it will be useful,`
13			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`// GNU General Public License for more details.`
16
17			`// Under Section 7 of GPL version 3, you are granted additional`
18			`// permissions described in the GCC Runtime Library Exception, version`
19			`// 3.1, as published by the Free Software Foundation.`
20
21			`// You should have received a copy of the GNU General Public License and`
22			`// a copy of the GCC Runtime Library Exception along with this program;`
23			`// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
24			`// <http://www.gnu.org/licenses/>.`
25
26			`/*`
27			`*`
28			`* Copyright (c) 1994`
29			`* Hewlett-Packard Company`
30			`*`
31			`* Permission to use, copy, modify, distribute and sell this software`
32			`* and its documentation for any purpose is hereby granted without fee,`
33			`* provided that the above copyright notice appear in all copies and`
34			`* that both that copyright notice and this permission notice appear`
35			`* in supporting documentation. Hewlett-Packard Company makes no`
36			`* representations about the suitability of this software for any`
37			`* purpose. It is provided "as is" without express or implied warranty.`
38			`*`
39			`*`
40			`* Copyright (c) 1996,1997`
41			`* Silicon Graphics Computer Systems, Inc.`
42			`*`
43			`* Permission to use, copy, modify, distribute and sell this software`
44			`* and its documentation for any purpose is hereby granted without fee,`
45			`* provided that the above copyright notice appear in all copies and`
46			`* that both that copyright notice and this permission notice appear`
47			`* in supporting documentation. Silicon Graphics makes no`
48			`* representations about the suitability of this software for any`
49			`* purpose. It is provided "as is" without express or implied warranty.`
50			`*/`
51
52			`/** @file bits/stl_numeric.h`
53			`* This is an internal header file, included by other library headers.`
54			`* Do not attempt to use it directly. @headername{numeric}`
55			`*/`
56
57			`#ifndef _STL_NUMERIC_H`
58			`#define _STL_NUMERIC_H 1`
59
60			`#include <bits/concept_check.h>`
61			`#include <debug/debug.h>`
62			`#include <bits/move.h> // For _GLIBCXX_MOVE`
63
64			`#if __cplusplus >= 201103L`
65
66			`namespace std _GLIBCXX_VISIBILITY(default)`
67			`{`
68			`_GLIBCXX_BEGIN_NAMESPACE_VERSION`
69
70			`/**`
71			`* @brief Create a range of sequentially increasing values.`
72			`*`
73			`* For each element in the range @p [first,last) assigns @p value and`
74			`* increments @p value as if by @p ++value.`
75			`*`
76			`* @param __first Start of range.`
77			`* @param __last End of range.`
78			`* @param __value Starting value.`
79			`* @return Nothing.`
80			`*/`
81			`template<typename _ForwardIterator, typename _Tp>`
82			`void`
83			`iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)`
84			`{`
85			`// concept requirements`
86			`__glibcxx_function_requires(_Mutable_ForwardIteratorConcept<`
87			`_ForwardIterator>)`
88			`__glibcxx_function_requires(_ConvertibleConcept<_Tp,`
89			`typename iterator_traits<_ForwardIterator>::value_type>)`
90			`__glibcxx_requires_valid_range(__first, __last);`
91
92			`for (; __first != __last; ++__first)`
93			`{`
94			`*__first = __value;`
95			`++__value;`
96			`}`
97			`}`
98
99			`_GLIBCXX_END_NAMESPACE_VERSION`
100			`} // namespace std`
101
102			`#endif`
103
104			`namespace std _GLIBCXX_VISIBILITY(default)`
105			`{`
106			`_GLIBCXX_BEGIN_NAMESPACE_ALGO`
107
108			`/**`
109			`* @brief Accumulate values in a range.`
110			`*`
111			`* Accumulates the values in the range [first,last) using operator+(). The`
112			`* initial value is @a init. The values are processed in order.`
113			`*`
114			`* @param __first Start of range.`
115			`* @param __last End of range.`
116			`* @param __init Starting value to add other values to.`
117			`* @return The final sum.`
118			`*/`
119			`template<typename _InputIterator, typename _Tp>`
120			`inline _Tp`
121			`accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)`
122			`{`
123			`// concept requirements`
124			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
125			`__glibcxx_requires_valid_range(__first, __last);`
126
127			`for (; __first != __last; ++__first)`
128			`__init = __init + *__first;`
129			`return __init;`
130			`}`
131
132			`/**`
133			`* @brief Accumulate values in a range with operation.`
134			`*`
135			`* Accumulates the values in the range [first,last) using the function`
136			`* object @p __binary_op. The initial value is @p __init. The values are`
137			`* processed in order.`
138			`*`
139			`* @param __first Start of range.`
140			`* @param __last End of range.`
141			`* @param __init Starting value to add other values to.`
142			`* @param __binary_op Function object to accumulate with.`
143			`* @return The final sum.`
144			`*/`
145			`template<typename _InputIterator, typename _Tp, typename _BinaryOperation>`
146			`inline _Tp`
147			`accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,`
148			`_BinaryOperation __binary_op)`
149			`{`
150			`// concept requirements`
151			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
152			`__glibcxx_requires_valid_range(__first, __last);`
153
154			`for (; __first != __last; ++__first)`
155			`__init = __binary_op(__init, *__first);`
156			`return __init;`
157			`}`
158
159			`/**`
160			`* @brief Compute inner product of two ranges.`
161			`*`
162			`* Starting with an initial value of @p __init, multiplies successive`
163			`* elements from the two ranges and adds each product into the accumulated`
164			`* value using operator+(). The values in the ranges are processed in`
165			`* order.`
166			`*`
167			`* @param __first1 Start of range 1.`
168			`* @param __last1 End of range 1.`
169			`* @param __first2 Start of range 2.`
170			`* @param __init Starting value to add other values to.`
171			`* @return The final inner product.`
172			`*/`
173			`template<typename _InputIterator1, typename _InputIterator2, typename _Tp>`
174			`inline _Tp`
175			`inner_product(_InputIterator1 __first1, _InputIterator1 __last1,`
176			`_InputIterator2 __first2, _Tp __init)`
177			`{`
178			`// concept requirements`
179			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)`
180			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)`
181			`__glibcxx_requires_valid_range(__first1, __last1);`
182
183			`for (; __first1 != __last1; ++__first1, ++__first2)`
184			`__init = __init + (__first1 *__first2);`
185			`return __init;`
186			`}`
187
188			`/**`
189			`* @brief Compute inner product of two ranges.`
190			`*`
191			`* Starting with an initial value of @p __init, applies @p __binary_op2 to`
192			`* successive elements from the two ranges and accumulates each result into`
193			`* the accumulated value using @p __binary_op1. The values in the ranges are`
194			`* processed in order.`
195			`*`
196			`* @param __first1 Start of range 1.`
197			`* @param __last1 End of range 1.`
198			`* @param __first2 Start of range 2.`
199			`* @param __init Starting value to add other values to.`
200			`* @param __binary_op1 Function object to accumulate with.`
201			`* @param __binary_op2 Function object to apply to pairs of input values.`
202			`* @return The final inner product.`
203			`*/`
204			`template<typename _InputIterator1, typename _InputIterator2, typename _Tp,`
205			`typename _BinaryOperation1, typename _BinaryOperation2>`
206			`inline _Tp`
207			`inner_product(_InputIterator1 __first1, _InputIterator1 __last1,`
208			`_InputIterator2 __first2, _Tp __init,`
209			`_BinaryOperation1 __binary_op1,`
210			`_BinaryOperation2 __binary_op2)`
211			`{`
212			`// concept requirements`
213			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)`
214			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)`
215			`__glibcxx_requires_valid_range(__first1, __last1);`
216
217			`for (; __first1 != __last1; ++__first1, ++__first2)`
218			`__init = __binary_op1(__init, __binary_op2(__first1, __first2));`
219			`return __init;`
220			`}`
221
222			`/**`
223			`* @brief Return list of partial sums`
224			`*`
225			`* Accumulates the values in the range [first,last) using the @c + operator.`
226			`* As each successive input value is added into the total, that partial sum`
227			`* is written to @p __result. Therefore, the first value in @p __result is`
228			`* the first value of the input, the second value in @p __result is the sum`
229			`* of the first and second input values, and so on.`
230			`*`
231			`* @param __first Start of input range.`
232			`* @param __last End of input range.`
233			`* @param __result Output sum.`
234			`* @return Iterator pointing just beyond the values written to __result.`
235			`*/`
236			`template<typename _InputIterator, typename _OutputIterator>`
237			`_OutputIterator`
238			`partial_sum(_InputIterator __first, _InputIterator __last,`
239			`_OutputIterator __result)`
240			`{`
241			`typedef typename iterator_traits<_InputIterator>::value_type _ValueType;`
242
243			`// concept requirements`
244			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
245			`__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,`
246			`_ValueType>)`
247			`__glibcxx_requires_valid_range(__first, __last);`
248
249			`if (__first == __last)`
250			`return __result;`
251			`_ValueType __value = *__first;`
252			`*__result = __value;`
253			`while (++__first != __last)`
254			`{`
255			`__value = __value + *__first;`
256			`*++__result = __value;`
257			`}`
258			`return ++__result;`
259			`}`
260
261			`/**`
262			`* @brief Return list of partial sums`
263			`*`
264			`* Accumulates the values in the range [first,last) using @p __binary_op.`
265			`* As each successive input value is added into the total, that partial sum`
266			`* is written to @p __result. Therefore, the first value in @p __result is`
267			`* the first value of the input, the second value in @p __result is the sum`
268			`* of the first and second input values, and so on.`
269			`*`
270			`* @param __first Start of input range.`
271			`* @param __last End of input range.`
272			`* @param __result Output sum.`
273			`* @param __binary_op Function object.`
274			`* @return Iterator pointing just beyond the values written to __result.`
275			`*/`
276			`template<typename _InputIterator, typename _OutputIterator,`
277			`typename _BinaryOperation>`
278			`_OutputIterator`
279			`partial_sum(_InputIterator __first, _InputIterator __last,`
280			`_OutputIterator __result, _BinaryOperation __binary_op)`
281			`{`
282			`typedef typename iterator_traits<_InputIterator>::value_type _ValueType;`
283
284			`// concept requirements`
285			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
286			`__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,`
287			`_ValueType>)`
288			`__glibcxx_requires_valid_range(__first, __last);`
289
290			`if (__first == __last)`
291			`return __result;`
292			`_ValueType __value = *__first;`
293			`*__result = __value;`
294			`while (++__first != __last)`
295			`{`
296			`__value = __binary_op(__value, *__first);`
297			`*++__result = __value;`
298			`}`
299			`return ++__result;`
300			`}`
301
302			`/**`
303			`* @brief Return differences between adjacent values.`
304			`*`
305			`* Computes the difference between adjacent values in the range`
306			`* [first,last) using operator-() and writes the result to @p __result.`
307			`*`
308			`* @param __first Start of input range.`
309			`* @param __last End of input range.`
310			`* @param __result Output sums.`
311			`* @return Iterator pointing just beyond the values written to result.`
312			`*`
313			`* _GLIBCXX_RESOLVE_LIB_DEFECTS`
314			`* DR 539. partial_sum and adjacent_difference should mention requirements`
315			`*/`
316			`template<typename _InputIterator, typename _OutputIterator>`
317			`_OutputIterator`
318			`adjacent_difference(_InputIterator __first,`
319			`_InputIterator __last, _OutputIterator __result)`
320			`{`
321			`typedef typename iterator_traits<_InputIterator>::value_type _ValueType;`
322
323			`// concept requirements`
324			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
325			`__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,`
326			`_ValueType>)`
327			`__glibcxx_requires_valid_range(__first, __last);`
328
329			`if (__first == __last)`
330			`return __result;`
331			`_ValueType __value = *__first;`
332			`*__result = __value;`
333			`while (++__first != __last)`
334			`{`
335			`_ValueType __tmp = *__first;`
336			`*++__result = __tmp - __value;`
337			`__value = _GLIBCXX_MOVE(__tmp);`
338			`}`
339			`return ++__result;`
340			`}`
341
342			`/**`
343			`* @brief Return differences between adjacent values.`
344			`*`
345			`* Computes the difference between adjacent values in the range`
346			`* [__first,__last) using the function object @p __binary_op and writes the`
347			`* result to @p __result.`
348			`*`
349			`* @param __first Start of input range.`
350			`* @param __last End of input range.`
351			`* @param __result Output sum.`
352			`* @param __binary_op Function object.`
353			`* @return Iterator pointing just beyond the values written to result.`
354			`*`
355			`* _GLIBCXX_RESOLVE_LIB_DEFECTS`
356			`* DR 539. partial_sum and adjacent_difference should mention requirements`
357			`*/`
358			`template<typename _InputIterator, typename _OutputIterator,`
359			`typename _BinaryOperation>`
360			`_OutputIterator`
361			`adjacent_difference(_InputIterator __first, _InputIterator __last,`
362			`_OutputIterator __result, _BinaryOperation __binary_op)`
363			`{`
364			`typedef typename iterator_traits<_InputIterator>::value_type _ValueType;`
365
366			`// concept requirements`
367			`__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)`
368			`__glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,`
369			`_ValueType>)`
370			`__glibcxx_requires_valid_range(__first, __last);`
371
372			`if (__first == __last)`
373			`return __result;`
374			`_ValueType __value = *__first;`
375			`*__result = __value;`
376			`while (++__first != __last)`
377			`{`
378			`_ValueType __tmp = *__first;`
379			`*++__result = __binary_op(__tmp, __value);`
380			`__value = _GLIBCXX_MOVE(__tmp);`
381			`}`
382			`return ++__result;`
383			`}`
384
385			`_GLIBCXX_END_NAMESPACE_ALGO`
386			`} // namespace std`
387
388			`#endif /* _STL_NUMERIC_H */`