overby.me
this repo has no description
1// -*- C++ -*-
2//===---------------------------- numeric ---------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_NUMERIC
12#define _LIBCPP_NUMERIC
13
14/*
15 numeric synopsis
16
17namespace std
18{
19
20template <class InputIterator, class T>
21 T
22 accumulate(InputIterator first, InputIterator last, T init);
23
24template <class InputIterator, class T, class BinaryOperation>
25 T
26 accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);
27
28template<class InputIterator>
29 typename iterator_traits<InputIterator>::value_type
30 reduce(InputIterator first, InputIterator last); // C++17
31
32template<class InputIterator, class T>
33 T
34 reduce(InputIterator first, InputIterator last, T init); // C++17
35
36template<class InputIterator, class T, class BinaryOperation>
37 T
38 reduce(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); // C++17
39
40template <class InputIterator1, class InputIterator2, class T>
41 T
42 inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);
43
44template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
45 T
46 inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
47 T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
48
49
50template<class InputIterator1, class InputIterator2, class T>
51 T
52 transform_reduce(InputIterator1 first1, InputIterator1 last1,
53 InputIterator2 first2, T init); // C++17
54
55template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
56 T
57 transform_reduce(InputIterator1 first1, InputIterator1 last1,
58 InputIterator2 first2, T init,
59 BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); // C++17
60
61template<class InputIterator, class T, class BinaryOperation, class UnaryOperation>
62 T
63 transform_reduce(InputIterator first, InputIterator last, T init,
64 BinaryOperation binary_op, UnaryOperation unary_op); // C++17
65
66template <class InputIterator, class OutputIterator>
67 OutputIterator
68 partial_sum(InputIterator first, InputIterator last, OutputIterator result);
69
70template <class InputIterator, class OutputIterator, class BinaryOperation>
71 OutputIterator
72 partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
73
74template<class InputIterator, class OutputIterator, class T>
75 OutputIterator
76 exclusive_scan(InputIterator first, InputIterator last,
77 OutputIterator result, T init); // C++17
78
79template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
80 OutputIterator
81 exclusive_scan(InputIterator first, InputIterator last,
82 OutputIterator result, T init, BinaryOperation binary_op); // C++17
83
84template<class InputIterator, class OutputIterator>
85 OutputIterator
86 inclusive_scan(InputIterator first, InputIterator last, OutputIterator result); // C++17
87
88template<class InputIterator, class OutputIterator, class BinaryOperation>
89 OutputIterator
90 inclusive_scan(InputIterator first, InputIterator last,
91 OutputIterator result, BinaryOperation binary_op); // C++17
92
93template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
94 OutputIterator
95 inclusive_scan(InputIterator first, InputIterator last,
96 OutputIterator result, BinaryOperation binary_op, T init); // C++17
97
98template<class InputIterator, class OutputIterator, class T,
99 class BinaryOperation, class UnaryOperation>
100 OutputIterator
101 transform_exclusive_scan(InputIterator first, InputIterator last,
102 OutputIterator result, T init,
103 BinaryOperation binary_op, UnaryOperation unary_op); // C++17
104
105template<class InputIterator, class OutputIterator,
106 class BinaryOperation, class UnaryOperation>
107 OutputIterator
108 transform_inclusive_scan(InputIterator first, InputIterator last,
109 OutputIterator result,
110 BinaryOperation binary_op, UnaryOperation unary_op); // C++17
111
112template<class InputIterator, class OutputIterator,
113 class BinaryOperation, class UnaryOperation, class T>
114 OutputIterator
115 transform_inclusive_scan(InputIterator first, InputIterator last,
116 OutputIterator result,
117 BinaryOperation binary_op, UnaryOperation unary_op,
118 T init); // C++17
119
120template <class InputIterator, class OutputIterator>
121 OutputIterator
122 adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);
123
124template <class InputIterator, class OutputIterator, class BinaryOperation>
125 OutputIterator
126 adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
127
128template <class ForwardIterator, class T>
129 void iota(ForwardIterator first, ForwardIterator last, T value);
130
131template <class M, class N>
132 constexpr common_type_t<M,N> gcd(M m, N n); // C++17
133
134template <class M, class N>
135 constexpr common_type_t<M,N> lcm(M m, N n); // C++17
136
137} // std
138
139*/
140
141#include <__config>
142#include <iterator>
143#include <limits> // for numeric_limits
144#include <functional>
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, __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