1// -*- C++ -*-
2//===---------------------------- numeric ---------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_NUMERIC
11#define _LIBCPP_NUMERIC
12
13/*
14    numeric synopsis
15
16namespace std
17{
18
19template <class InputIterator, class T>
20    T
21    accumulate(InputIterator first, InputIterator last, T init);
22
23template <class InputIterator, class T, class BinaryOperation>
24    T
25    accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);
26
27template<class InputIterator>
28    typename iterator_traits<InputIterator>::value_type
29    reduce(InputIterator first, InputIterator last);  // C++17
30
31template<class InputIterator, class T>
32    T
33    reduce(InputIterator first, InputIterator last, T init);  // C++17
34
35template<class InputIterator, class T, class BinaryOperation>
36    T
37    reduce(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);  // C++17
38
39template <class InputIterator1, class InputIterator2, class T>
40    T
41    inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);
42
43template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
44    T
45    inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
46                  T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
47
48
49template<class InputIterator1, class InputIterator2, class T>
50    T
51    transform_reduce(InputIterator1 first1, InputIterator1 last1,
52                     InputIterator2 first2, T init);  // C++17
53
54template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
55    T
56    transform_reduce(InputIterator1 first1, InputIterator1 last1,
57                     InputIterator2 first2, T init,
58                     BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);  // C++17
59
60template<class InputIterator, class T, class BinaryOperation, class UnaryOperation>
61    T
62    transform_reduce(InputIterator first, InputIterator last, T init,
63                     BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
64
65template <class InputIterator, class OutputIterator>
66    OutputIterator
67    partial_sum(InputIterator first, InputIterator last, OutputIterator result);
68
69template <class InputIterator, class OutputIterator, class BinaryOperation>
70    OutputIterator
71    partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
72
73template<class InputIterator, class OutputIterator, class T>
74    OutputIterator
75    exclusive_scan(InputIterator first, InputIterator last,
76                   OutputIterator result, T init); // C++17
77
78template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
79    OutputIterator
80    exclusive_scan(InputIterator first, InputIterator last,
81                   OutputIterator result, T init, BinaryOperation binary_op); // C++17
82
83template<class InputIterator, class OutputIterator>
84    OutputIterator
85    inclusive_scan(InputIterator first, InputIterator last, OutputIterator result);  // C++17
86
87template<class InputIterator, class OutputIterator, class BinaryOperation>
88    OutputIterator
89    inclusive_scan(InputIterator first, InputIterator last,
90                   OutputIterator result, BinaryOperation binary_op);  // C++17
91
92template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
93    OutputIterator
94    inclusive_scan(InputIterator first, InputIterator last,
95                   OutputIterator result, BinaryOperation binary_op, T init);  // C++17
96
97template<class InputIterator, class OutputIterator, class T,
98         class BinaryOperation, class UnaryOperation>
99    OutputIterator
100    transform_exclusive_scan(InputIterator first, InputIterator last,
101                             OutputIterator result, T init,
102                             BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
103
104template<class InputIterator, class OutputIterator,
105         class BinaryOperation, class UnaryOperation>
106    OutputIterator
107    transform_inclusive_scan(InputIterator first, InputIterator last,
108                             OutputIterator result,
109                             BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
110
111template<class InputIterator, class OutputIterator,
112         class BinaryOperation, class UnaryOperation, class T>
113    OutputIterator
114    transform_inclusive_scan(InputIterator first, InputIterator last,
115                             OutputIterator result,
116                             BinaryOperation binary_op, UnaryOperation unary_op,
117                             T init);  // C++17
118
119template <class InputIterator, class OutputIterator>
120    OutputIterator
121    adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);
122
123template <class InputIterator, class OutputIterator, class BinaryOperation>
124    OutputIterator
125    adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
126
127template <class ForwardIterator, class T>
128    void iota(ForwardIterator first, ForwardIterator last, T value);
129
130template <class M, class N>
131    constexpr common_type_t<M,N> gcd(M m, N n);    // C++17
132
133template <class M, class N>
134    constexpr common_type_t<M,N> lcm(M m, N n);    // C++17
135
136}  // std
137
138*/
139
140#include <__config>
141#include <iterator>
142#include <limits> // for numeric_limits
143#include <functional>
144#include <version>
145
146#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
147#pragma GCC system_header
148#endif
149
150_LIBCPP_PUSH_MACROS
151#include <__undef_macros>
152
153_LIBCPP_BEGIN_NAMESPACE_STD
154
155template <class _InputIterator, class _Tp>
156inline _LIBCPP_INLINE_VISIBILITY
157_Tp
158accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
159{
160    for (; __first != __last; ++__first)
161        __init = __init + *__first;
162    return __init;
163}
164
165template <class _InputIterator, class _Tp, class _BinaryOperation>
166inline _LIBCPP_INLINE_VISIBILITY
167_Tp
168accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
169{
170    for (; __first != __last; ++__first)
171        __init = __binary_op(__init, *__first);
172    return __init;
173}
174
175#if _LIBCPP_STD_VER > 14
176template <class _InputIterator, class _Tp, class _BinaryOp>
177inline _LIBCPP_INLINE_VISIBILITY
178_Tp
179reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b)
180{
181    for (; __first != __last; ++__first)
182        __init = __b(__init, *__first);
183    return __init;
184}
185
186template <class _InputIterator, class _Tp>
187inline _LIBCPP_INLINE_VISIBILITY
188_Tp
189reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
190{
191    return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
192}
193
194template <class _InputIterator>
195inline _LIBCPP_INLINE_VISIBILITY
196typename iterator_traits<_InputIterator>::value_type
197reduce(_InputIterator __first, _InputIterator __last)
198{
199    return _VSTD::reduce(__first, __last,
200       typename iterator_traits<_InputIterator>::value_type{});
201}
202#endif
203
204template <class _InputIterator1, class _InputIterator2, class _Tp>
205inline _LIBCPP_INLINE_VISIBILITY
206_Tp
207inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
208{
209    for (; __first1 != __last1; ++__first1, (void) ++__first2)
210        __init = __init + *__first1 * *__first2;
211    return __init;
212}
213
214template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
215inline _LIBCPP_INLINE_VISIBILITY
216_Tp
217inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
218              _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
219{
220    for (; __first1 != __last1; ++__first1, (void) ++__first2)
221        __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
222    return __init;
223}
224
225#if _LIBCPP_STD_VER > 14
226template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
227inline _LIBCPP_INLINE_VISIBILITY
228_Tp
229transform_reduce(_InputIterator __first, _InputIterator __last,
230           _Tp __init,  _BinaryOp __b, _UnaryOp __u)
231{
232    for (; __first != __last; ++__first)
233        __init = __b(__init, __u(*__first));
234    return __init;
235}
236
237template <class _InputIterator1, class _InputIterator2,
238          class _Tp, class _BinaryOp1, class _BinaryOp2>
239inline _LIBCPP_INLINE_VISIBILITY
240_Tp
241transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
242                 _InputIterator2 __first2, _Tp __init,  _BinaryOp1 __b1, _BinaryOp2 __b2)
243{
244    for (; __first1 != __last1; ++__first1, (void) ++__first2)
245        __init = __b1(__init, __b2(*__first1, *__first2));
246    return __init;
247}
248
249template <class _InputIterator1, class _InputIterator2, class _Tp>
250inline _LIBCPP_INLINE_VISIBILITY
251_Tp
252transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
253                 _InputIterator2 __first2, _Tp __init)
254{
255    return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init),
256                                   _VSTD::plus<>(), _VSTD::multiplies<>());
257}
258#endif
259
260template <class _InputIterator, class _OutputIterator>
261inline _LIBCPP_INLINE_VISIBILITY
262_OutputIterator
263partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
264{
265    if (__first != __last)
266    {
267        typename iterator_traits<_InputIterator>::value_type __t(*__first);
268        *__result = __t;
269        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
270        {
271            __t = __t + *__first;
272            *__result = __t;
273        }
274    }
275    return __result;
276}
277
278template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
279inline _LIBCPP_INLINE_VISIBILITY
280_OutputIterator
281partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
282              _BinaryOperation __binary_op)
283{
284    if (__first != __last)
285    {
286        typename iterator_traits<_InputIterator>::value_type __t(*__first);
287        *__result = __t;
288        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
289        {
290            __t = __binary_op(__t, *__first);
291            *__result = __t;
292        }
293    }
294    return __result;
295}
296
297#if _LIBCPP_STD_VER > 14
298template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
299inline _LIBCPP_INLINE_VISIBILITY
300_OutputIterator
301exclusive_scan(_InputIterator __first, _InputIterator __last,
302               _OutputIterator __result, _Tp __init, _BinaryOp __b)
303{
304    if (__first != __last)
305    {
306        _Tp __saved = __init;
307        do
308        {
309            __init = __b(__init, *__first);
310            *__result = __saved;
311            __saved = __init;
312            ++__result;
313        } while (++__first != __last);
314    }
315    return __result;
316}
317
318template <class _InputIterator, class _OutputIterator, class _Tp>
319inline _LIBCPP_INLINE_VISIBILITY
320_OutputIterator
321exclusive_scan(_InputIterator __first, _InputIterator __last,
322               _OutputIterator __result, _Tp __init)
323{
324    return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
325}
326
327template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
328_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
329                               _OutputIterator __result, _BinaryOp __b,  _Tp __init)
330{
331    for (; __first != __last; ++__first, (void) ++__result) {
332        __init = __b(__init, *__first);
333        *__result = __init;
334        }
335    return __result;
336}
337
338template <class _InputIterator, class _OutputIterator, class _BinaryOp>
339_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
340                               _OutputIterator __result, _BinaryOp __b)
341{
342    if (__first != __last) {
343        typename std::iterator_traits<_InputIterator>::value_type __init = *__first;
344        *__result++ = __init;
345        if (++__first != __last)
346            return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
347        }
348
349    return __result;
350}
351
352template <class _InputIterator, class _OutputIterator>
353_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
354                               _OutputIterator __result)
355{
356    return _VSTD::inclusive_scan(__first, __last, __result, std::plus<>());
357}
358
359template <class _InputIterator, class _OutputIterator, class _Tp,
360          class _BinaryOp, class _UnaryOp>
361inline _LIBCPP_INLINE_VISIBILITY
362_OutputIterator
363transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
364                           _OutputIterator __result, _Tp __init,
365                           _BinaryOp __b, _UnaryOp __u)
366{
367    if (__first != __last)
368    {
369        _Tp __saved = __init;
370        do
371        {
372            __init = __b(__init, __u(*__first));
373            *__result = __saved;
374            __saved = __init;
375            ++__result;
376        } while (++__first != __last);
377    }
378    return __result;
379}
380
381template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
382_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
383                           _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
384{
385    for (; __first != __last; ++__first, (void) ++__result) {
386        __init = __b(__init, __u(*__first));
387        *__result = __init;
388        }
389
390    return __result;
391}
392
393template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
394_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
395                               _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
396{
397    if (__first != __last) {
398        typename std::iterator_traits<_InputIterator>::value_type __init = __u(*__first);
399        *__result++ = __init;
400        if (++__first != __last)
401            return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
402        }
403
404    return __result;
405}
406#endif
407
408template <class _InputIterator, class _OutputIterator>
409inline _LIBCPP_INLINE_VISIBILITY
410_OutputIterator
411adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
412{
413    if (__first != __last)
414    {
415        typename iterator_traits<_InputIterator>::value_type __t1(*__first);
416        *__result = __t1;
417        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
418        {
419            typename iterator_traits<_InputIterator>::value_type __t2(*__first);
420            *__result = __t2 - __t1;
421            __t1 = _VSTD::move(__t2);
422        }
423    }
424    return __result;
425}
426
427template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
428inline _LIBCPP_INLINE_VISIBILITY
429_OutputIterator
430adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
431                      _BinaryOperation __binary_op)
432{
433    if (__first != __last)
434    {
435        typename iterator_traits<_InputIterator>::value_type __t1(*__first);
436        *__result = __t1;
437        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
438        {
439            typename iterator_traits<_InputIterator>::value_type __t2(*__first);
440            *__result = __binary_op(__t2, __t1);
441            __t1 = _VSTD::move(__t2);
442        }
443    }
444    return __result;
445}
446
447template <class _ForwardIterator, class _Tp>
448inline _LIBCPP_INLINE_VISIBILITY
449void
450iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
451{
452    for (; __first != __last; ++__first, (void) ++__value_)
453        *__first = __value_;
454}
455
456
457#if _LIBCPP_STD_VER > 14
458template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __abs;
459
460template <typename _Result, typename _Source>
461struct __abs<_Result, _Source, true> {
462    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
463    _Result operator()(_Source __t) const noexcept
464    {
465    if (__t >= 0) return __t;
466    if (__t == numeric_limits<_Source>::min()) return -static_cast<_Result>(__t);
467    return -__t;
468    }
469};
470
471template <typename _Result, typename _Source>
472struct __abs<_Result, _Source, false> {
473    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
474    _Result operator()(_Source __t) const noexcept { return __t; }
475};
476
477
478template<class _Tp>
479_LIBCPP_CONSTEXPR _LIBCPP_HIDDEN
480_Tp __gcd(_Tp __m, _Tp __n)
481{
482    static_assert((!is_signed<_Tp>::value), "");
483    return __n == 0 ? __m : _VSTD::__gcd<_Tp>(__n, __m % __n);
484}
485
486
487template<class _Tp, class _Up>
488_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
489common_type_t<_Tp,_Up>
490gcd(_Tp __m, _Up __n)
491{
492    static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types");
493    static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to gcd cannot be bool" );
494    static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to gcd cannot be bool" );
495    using _Rp = common_type_t<_Tp,_Up>;
496    using _Wp = make_unsigned_t<_Rp>;
497    return static_cast<_Rp>(_VSTD::__gcd(
498        static_cast<_Wp>(__abs<_Rp, _Tp>()(__m)),
499        static_cast<_Wp>(__abs<_Rp, _Up>()(__n))));
500}
501
502template<class _Tp, class _Up>
503_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
504common_type_t<_Tp,_Up>
505lcm(_Tp __m, _Up __n)
506{
507    static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types");
508    static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to lcm cannot be bool" );
509    static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to lcm cannot be bool" );
510    if (__m == 0 || __n == 0)
511        return 0;
512
513    using _Rp = common_type_t<_Tp,_Up>;
514    _Rp __val1 = __abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n);
515    _Rp __val2 = __abs<_Rp, _Up>()(__n);
516    _LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm");
517    return __val1 * __val2;
518}
519
520#endif /* _LIBCPP_STD_VER > 14 */
521
522_LIBCPP_END_NAMESPACE_STD
523
524_LIBCPP_POP_MACROS
525
526#endif  // _LIBCPP_NUMERIC
527