libstdc++
valarray_after.h
Go to the documentation of this file.
1// The template and inlines for the -*- C++ -*- internal _Meta class.
2
3// Copyright (C) 1997-2021 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/valarray_after.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{valarray}
28 */
29
30// Written by Gabriel Dos Reis <[email protected]>
31
32#ifndef _VALARRAY_AFTER_H
33#define _VALARRAY_AFTER_H 1
34
35#pragma GCC system_header
36
37namespace std _GLIBCXX_VISIBILITY(default)
38{
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
40
41namespace __detail
42{
43 //
44 // gslice_array closure.
45 //
46 template<class _Dom>
47 class _GBase
48 {
49 public:
50 typedef typename _Dom::value_type value_type;
51
52 _GBase (const _Dom& __e, const valarray<size_t>& __i)
53 : _M_expr (__e), _M_index(__i) {}
54
55 value_type
56 operator[] (size_t __i) const
57 { return _M_expr[_M_index[__i]]; }
58
59 size_t
60 size () const
61 { return _M_index.size(); }
62
63 private:
64 typename _ValArrayRef<_Dom>::__type _M_expr;
65 const valarray<size_t>& _M_index;
66 };
67
68 template<typename _Tp>
69 class _GBase<_Array<_Tp> >
70 {
71 public:
72 typedef _Tp value_type;
73
74 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
75 : _M_array (__a), _M_index(__i) {}
76
77 value_type
78 operator[] (size_t __i) const
79 { return _M_array._M_data[_M_index[__i]]; }
80
81 size_t
82 size () const
83 { return _M_index.size(); }
84
85 private:
86 const _Array<_Tp> _M_array;
87 const valarray<size_t>& _M_index;
88 };
89
90 template<class _Dom>
91 struct _GClos<_Expr, _Dom>
92 : _GBase<_Dom>
93 {
94 typedef _GBase<_Dom> _Base;
95 typedef typename _Base::value_type value_type;
96
97 _GClos (const _Dom& __e, const valarray<size_t>& __i)
98 : _Base (__e, __i) {}
99 };
100
101 template<typename _Tp>
102 struct _GClos<_ValArray, _Tp>
103 : _GBase<_Array<_Tp> >
104 {
105 typedef _GBase<_Array<_Tp> > _Base;
106 typedef typename _Base::value_type value_type;
107
108 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
109 : _Base (__a, __i) {}
110 };
111
112 //
113 // indirect_array closure
114 //
115 template<class _Dom>
116 class _IBase
117 {
118 public:
119 typedef typename _Dom::value_type value_type;
120
121 _IBase (const _Dom& __e, const valarray<size_t>& __i)
122 : _M_expr (__e), _M_index (__i) {}
123
124 value_type
125 operator[] (size_t __i) const
126 { return _M_expr[_M_index[__i]]; }
127
128 size_t
129 size() const
130 { return _M_index.size(); }
131
132 private:
133 typename _ValArrayRef<_Dom>::__type _M_expr;
134 const valarray<size_t>& _M_index;
135 };
136
137 template<class _Dom>
138 struct _IClos<_Expr, _Dom>
139 : _IBase<_Dom>
140 {
141 typedef _IBase<_Dom> _Base;
142 typedef typename _Base::value_type value_type;
143
144 _IClos (const _Dom& __e, const valarray<size_t>& __i)
145 : _Base (__e, __i) {}
146 };
147
148 template<typename _Tp>
149 struct _IClos<_ValArray, _Tp>
150 : _IBase<valarray<_Tp> >
151 {
152 typedef _IBase<valarray<_Tp> > _Base;
153 typedef _Tp value_type;
154
155 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
156 : _Base (__a, __i) {}
157 };
158} // namespace __detail
159
160 //
161 // class _Expr
162 //
163 template<class _Clos, typename _Tp>
164 class _Expr
165 {
166 public:
167 typedef _Tp value_type;
168
169 _Expr(const _Clos&);
170
171 const _Clos& operator()() const;
172
173 value_type operator[](size_t) const;
174 valarray<value_type> operator[](slice) const;
175 valarray<value_type> operator[](const gslice&) const;
176 valarray<value_type> operator[](const valarray<bool>&) const;
177 valarray<value_type> operator[](const valarray<size_t>&) const;
178
179 _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
180 operator+() const;
181
182 _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
183 operator-() const;
184
185 _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
186 operator~() const;
187
188 _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
189 operator!() const;
190
191 size_t size() const;
192 value_type sum() const;
193
194 valarray<value_type> shift(int) const;
195 valarray<value_type> cshift(int) const;
196
197 value_type min() const;
198 value_type max() const;
199
200 valarray<value_type> apply(value_type (*)(const value_type&)) const;
201 valarray<value_type> apply(value_type (*)(value_type)) const;
202
203 private:
204 const _Clos _M_closure;
205 };
206
207 template<class _Clos, typename _Tp>
208 inline
209 _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
210
211 template<class _Clos, typename _Tp>
212 inline const _Clos&
213 _Expr<_Clos, _Tp>::operator()() const
214 { return _M_closure; }
215
216 template<class _Clos, typename _Tp>
217 inline _Tp
218 _Expr<_Clos, _Tp>::operator[](size_t __i) const
219 { return _M_closure[__i]; }
220
221 template<class _Clos, typename _Tp>
222 inline valarray<_Tp>
223 _Expr<_Clos, _Tp>::operator[](slice __s) const
224 {
225 valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
226 return __v;
227 }
228
229 template<class _Clos, typename _Tp>
230 inline valarray<_Tp>
231 _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
232 {
233 valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
234 return __v;
235 }
236
237 template<class _Clos, typename _Tp>
238 inline valarray<_Tp>
239 _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
240 {
241 valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
242 return __v;
243 }
244
245 template<class _Clos, typename _Tp>
246 inline valarray<_Tp>
247 _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
248 {
249 valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
250 return __v;
251 }
252
253 template<class _Clos, typename _Tp>
254 inline size_t
255 _Expr<_Clos, _Tp>::size() const
256 { return _M_closure.size(); }
257
258 template<class _Clos, typename _Tp>
259 inline valarray<_Tp>
260 _Expr<_Clos, _Tp>::shift(int __n) const
261 {
262 valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
263 return __v;
264 }
265
266 template<class _Clos, typename _Tp>
267 inline valarray<_Tp>
268 _Expr<_Clos, _Tp>::cshift(int __n) const
269 {
270 valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
271 return __v;
272 }
273
274 template<class _Clos, typename _Tp>
275 inline valarray<_Tp>
276 _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
277 {
278 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
279 return __v;
280 }
281
282 template<class _Clos, typename _Tp>
283 inline valarray<_Tp>
284 _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
285 {
286 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
287 return __v;
288 }
289
290 // XXX: replace this with a more robust summation algorithm.
291 template<class _Clos, typename _Tp>
292 inline _Tp
293 _Expr<_Clos, _Tp>::sum() const
294 {
295 size_t __n = _M_closure.size();
296 if (__n == 0)
297 return _Tp();
298 else
299 {
300 _Tp __s = _M_closure[--__n];
301 while (__n != 0)
302 __s += _M_closure[--__n];
303 return __s;
304 }
305 }
306
307 template<class _Clos, typename _Tp>
308 inline _Tp
309 _Expr<_Clos, _Tp>::min() const
310 { return __valarray_min(_M_closure); }
311
312 template<class _Clos, typename _Tp>
313 inline _Tp
314 _Expr<_Clos, _Tp>::max() const
315 { return __valarray_max(_M_closure); }
316
317 template<class _Dom, typename _Tp>
318 inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
319 _Expr<_Dom, _Tp>::operator!() const
320 {
321 typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
322 return _Expr<_Closure, bool>(_Closure(this->_M_closure));
323 }
324
325#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
326 template<class _Dom, typename _Tp> \
327 inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \
328 _Expr<_Dom, _Tp>::operator _Op() const \
329 { \
330 typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \
331 return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \
332 }
333
334 _DEFINE_EXPR_UNARY_OPERATOR(+, struct std::__unary_plus)
335 _DEFINE_EXPR_UNARY_OPERATOR(-, struct std::__negate)
336 _DEFINE_EXPR_UNARY_OPERATOR(~, struct std::__bitwise_not)
337
338#undef _DEFINE_EXPR_UNARY_OPERATOR
339
340#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
341 template<class _Dom1, class _Dom2> \
342 inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \
343 typename __fun<_Name, typename _Dom1::value_type>::result_type> \
344 operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \
345 const _Expr<_Dom2, typename _Dom2::value_type>& __w) \
346 { \
347 typedef typename _Dom1::value_type _Arg; \
348 typedef typename __fun<_Name, _Arg>::result_type _Value; \
349 typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
350 return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \
351 } \
352 \
353 template<class _Dom> \
354 inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \
355 typename _Dom::value_type>, \
356 typename __fun<_Name, typename _Dom::value_type>::result_type> \
357 operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \
358 const typename _Dom::value_type& __t) \
359 { \
360 typedef typename _Dom::value_type _Arg; \
361 typedef typename __fun<_Name, _Arg>::result_type _Value; \
362 typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \
363 return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \
364 } \
365 \
366 template<class _Dom> \
367 inline _Expr<_BinClos<_Name, _Constant, _Expr, \
368 typename _Dom::value_type, _Dom>, \
369 typename __fun<_Name, typename _Dom::value_type>::result_type> \
370 operator _Op(const typename _Dom::value_type& __t, \
371 const _Expr<_Dom, typename _Dom::value_type>& __v) \
372 { \
373 typedef typename _Dom::value_type _Arg; \
374 typedef typename __fun<_Name, _Arg>::result_type _Value; \
375 typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \
376 return _Expr<_Closure, _Value>(_Closure(__t, __v())); \
377 } \
378 \
379 template<class _Dom> \
380 inline _Expr<_BinClos<_Name, _Expr, _ValArray, \
381 _Dom, typename _Dom::value_type>, \
382 typename __fun<_Name, typename _Dom::value_type>::result_type> \
383 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
384 const valarray<typename _Dom::value_type>& __v) \
385 { \
386 typedef typename _Dom::value_type _Arg; \
387 typedef typename __fun<_Name, _Arg>::result_type _Value; \
388 typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \
389 return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \
390 } \
391 \
392 template<class _Dom> \
393 inline _Expr<_BinClos<_Name, _ValArray, _Expr, \
394 typename _Dom::value_type, _Dom>, \
395 typename __fun<_Name, typename _Dom::value_type>::result_type> \
396 operator _Op(const valarray<typename _Dom::value_type>& __v, \
397 const _Expr<_Dom, typename _Dom::value_type>& __e) \
398 { \
399 typedef typename _Dom::value_type _Tp; \
400 typedef typename __fun<_Name, _Tp>::result_type _Value; \
401 typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \
402 return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \
403 }
404
405 _DEFINE_EXPR_BINARY_OPERATOR(+, struct std::__plus)
406 _DEFINE_EXPR_BINARY_OPERATOR(-, struct std::__minus)
407 _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
408 _DEFINE_EXPR_BINARY_OPERATOR(/, struct std::__divides)
409 _DEFINE_EXPR_BINARY_OPERATOR(%, struct std::__modulus)
410 _DEFINE_EXPR_BINARY_OPERATOR(^, struct std::__bitwise_xor)
411 _DEFINE_EXPR_BINARY_OPERATOR(&, struct std::__bitwise_and)
412 _DEFINE_EXPR_BINARY_OPERATOR(|, struct std::__bitwise_or)
413 _DEFINE_EXPR_BINARY_OPERATOR(<<, struct std::__shift_left)
414 _DEFINE_EXPR_BINARY_OPERATOR(>>, struct std::__shift_right)
415 _DEFINE_EXPR_BINARY_OPERATOR(&&, struct std::__logical_and)
416 _DEFINE_EXPR_BINARY_OPERATOR(||, struct std::__logical_or)
417 _DEFINE_EXPR_BINARY_OPERATOR(==, struct std::__equal_to)
418 _DEFINE_EXPR_BINARY_OPERATOR(!=, struct std::__not_equal_to)
419 _DEFINE_EXPR_BINARY_OPERATOR(<, struct std::__less)
420 _DEFINE_EXPR_BINARY_OPERATOR(>, struct std::__greater)
421 _DEFINE_EXPR_BINARY_OPERATOR(<=, struct std::__less_equal)
422 _DEFINE_EXPR_BINARY_OPERATOR(>=, struct std::__greater_equal)
423
424#undef _DEFINE_EXPR_BINARY_OPERATOR
425
426#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName) \
427 template<class _Dom> \
428 inline _Expr<_UnClos<_UName, _Expr, _Dom>, \
429 typename _Dom::value_type> \
430 _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \
431 { \
432 typedef typename _Dom::value_type _Tp; \
433 typedef _UnClos<_UName, _Expr, _Dom> _Closure; \
434 return _Expr<_Closure, _Tp>(_Closure(__e())); \
435 } \
436 \
437 template<typename _Tp> \
438 inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp> \
439 _Name(const valarray<_Tp>& __v) \
440 { \
441 typedef _UnClos<_UName, _ValArray, _Tp> _Closure; \
442 return _Expr<_Closure, _Tp>(_Closure(__v)); \
443 }
444
445 _DEFINE_EXPR_UNARY_FUNCTION(abs, struct std::_Abs)
446 _DEFINE_EXPR_UNARY_FUNCTION(cos, struct std::_Cos)
447 _DEFINE_EXPR_UNARY_FUNCTION(acos, struct std::_Acos)
448 _DEFINE_EXPR_UNARY_FUNCTION(cosh, struct std::_Cosh)
449 _DEFINE_EXPR_UNARY_FUNCTION(sin, struct std::_Sin)
450 _DEFINE_EXPR_UNARY_FUNCTION(asin, struct std::_Asin)
451 _DEFINE_EXPR_UNARY_FUNCTION(sinh, struct std::_Sinh)
452 _DEFINE_EXPR_UNARY_FUNCTION(tan, struct std::_Tan)
453 _DEFINE_EXPR_UNARY_FUNCTION(tanh, struct std::_Tanh)
454 _DEFINE_EXPR_UNARY_FUNCTION(atan, struct std::_Atan)
455 _DEFINE_EXPR_UNARY_FUNCTION(exp, struct std::_Exp)
456 _DEFINE_EXPR_UNARY_FUNCTION(log, struct std::_Log)
457 _DEFINE_EXPR_UNARY_FUNCTION(log10, struct std::_Log10)
458 _DEFINE_EXPR_UNARY_FUNCTION(sqrt, struct std::_Sqrt)
459
460#undef _DEFINE_EXPR_UNARY_FUNCTION
461
462#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun) \
463 template<class _Dom1, class _Dom2> \
464 inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>, \
465 typename _Dom1::value_type> \
466 _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \
467 const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \
468 { \
469 typedef typename _Dom1::value_type _Tp; \
470 typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
471 return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \
472 } \
473 \
474 template<class _Dom> \
475 inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom, \
476 typename _Dom::value_type>, \
477 typename _Dom::value_type> \
478 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
479 const valarray<typename _Dom::value_type>& __v) \
480 { \
481 typedef typename _Dom::value_type _Tp; \
482 typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure; \
483 return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \
484 } \
485 \
486 template<class _Dom> \
487 inline _Expr<_BinClos<_UFun, _ValArray, _Expr, \
488 typename _Dom::value_type, _Dom>, \
489 typename _Dom::value_type> \
490 _Fun(const valarray<typename _Dom::valarray>& __v, \
491 const _Expr<_Dom, typename _Dom::value_type>& __e) \
492 { \
493 typedef typename _Dom::value_type _Tp; \
494 typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure; \
495 return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \
496 } \
497 \
498 template<class _Dom> \
499 inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom, \
500 typename _Dom::value_type>, \
501 typename _Dom::value_type> \
502 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
503 const typename _Dom::value_type& __t) \
504 { \
505 typedef typename _Dom::value_type _Tp; \
506 typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure; \
507 return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \
508 } \
509 \
510 template<class _Dom> \
511 inline _Expr<_BinClos<_UFun, _Constant, _Expr, \
512 typename _Dom::value_type, _Dom>, \
513 typename _Dom::value_type> \
514 _Fun(const typename _Dom::value_type& __t, \
515 const _Expr<_Dom, typename _Dom::value_type>& __e) \
516 { \
517 typedef typename _Dom::value_type _Tp; \
518 typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure; \
519 return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \
520 } \
521 \
522 template<typename _Tp> \
523 inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
524 _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
525 { \
526 typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
527 return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \
528 } \
529 \
530 template<typename _Tp> \
531 inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
532 _Fun(const valarray<_Tp>& __v, \
533 const typename valarray<_Tp>::value_type& __t) \
534 { \
535 typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
536 return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \
537 } \
538 \
539 template<typename _Tp> \
540 inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
541 _Fun(const typename valarray<_Tp>::value_type& __t, \
542 const valarray<_Tp>& __v) \
543 { \
544 typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
545 return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
546 }
547
548_DEFINE_EXPR_BINARY_FUNCTION(atan2, struct std::_Atan2)
549_DEFINE_EXPR_BINARY_FUNCTION(pow, struct std::_Pow)
550
551#undef _DEFINE_EXPR_BINARY_FUNCTION
552
553_GLIBCXX_END_NAMESPACE_VERSION
554} // namespace
555
556#endif /* _CPP_VALARRAY_AFTER_H */
std::chrono::operator+
constexpr time_point< _Clock, typename common_type< duration< _Rep1, _Period1 >, _Dur2 >::type > operator+(const duration< _Rep1, _Period1 > &__lhs, const time_point< _Clock, _Dur2 > &__rhs)
Adjust a time point forwards by the given duration.
Definition: chrono:1016
std::chrono::operator-
constexpr common_type< duration< _Rep1, _Period1 >, duration< _Rep2, _Period2 > >::type operator-(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
The difference between two durations.
Definition: chrono:660
std::max
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:254
std::min
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
std
ISO C++ entities toplevel namespace is std.
std::size
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:245