timemory 3.3.0
Modular C++ Toolkit for Performance Analysis and Logging. Profiling API and Tools for C, C++, CUDA, Fortran, and Python. The C++ template API is essentially a framework to creating tools: it is designed to provide a unifying interface for recording various performance measurements alongside data logging and interfaces to other tools.
Namespaces | Functions
tim::stl Namespace Reference

the namespace is provided to hide stl overload from global namespace but provide a method of using the namespace without a "using namespace tim;" More...

Namespaces

namespace  ostream
 the namespace provides overloads to output complex data types w/ streams
 

Functions

template<typename Tp , size_t N, typename Other >
std::array< Tp, N > & operator+= (std::array< Tp, N > &, Other &&)
 
template<typename Lhs , typename Rhs , typename Other >
std::pair< Lhs, Rhs > & operator+= (std::pair< Lhs, Rhs > &, Other &&)
 
template<typename Tp , typename... _Extra, typename Other >
std::vector< Tp, _Extra... > & operator+= (std::vector< Tp, _Extra... > &, Other &&)
 
template<typename... Types, typename Other >
std::tuple< Types... > & operator+= (std::tuple< Types... > &, Other &&)
 
template<typename Tp , size_t N>
std::array< Tp, N > & operator-= (std::array< Tp, N > &, const std::array< Tp, N > &)
 
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & operator-= (std::array< Lhs, N > &, const Rhs &)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & operator-= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
 
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & operator-= (std::pair< Lhs, Rhs > &, const ArithT &)
 
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & operator-= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
 
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & operator-= (std::vector< Lhs, _Extra... > &, const Rhs &)
 
template<typename... Types>
std::tuple< Types... > & operator-= (std::tuple< Types... > &, const std::tuple< Types... > &)
 
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & operator-= (std::tuple< Lhs... > &, const Rhs &)
 
template<typename Tp , size_t N>
std::array< Tp, N > & operator*= (std::array< Tp, N > &, const std::array< Tp, N > &)
 
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & operator*= (std::array< Lhs, N > &, const Rhs &)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & operator*= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
 
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & operator*= (std::pair< Lhs, Rhs > &, const ArithT &)
 
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & operator*= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
 
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & operator*= (std::vector< Lhs, _Extra... > &, const Rhs &)
 
template<typename... Types>
std::tuple< Types... > & operator*= (std::tuple< Types... > &, const std::tuple< Types... > &)
 
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & operator*= (std::tuple< Lhs... > &, const Rhs &)
 
template<typename Tp , size_t N>
std::array< Tp, N > & operator/= (std::array< Tp, N > &, const std::array< Tp, N > &)
 
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & operator/= (std::array< Lhs, N > &, const Rhs &)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & operator/= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
 
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & operator/= (std::pair< Lhs, Rhs > &, const ArithT &)
 
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & operator/= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
 
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & operator/= (std::vector< Lhs, _Extra... > &, const Rhs &)
 
template<typename... Types>
std::tuple< Types... > & operator/= (std::tuple< Types... > &, const std::tuple< Types... > &)
 
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & operator/= (std::tuple< Lhs... > &, const Rhs &)
 
template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs operator* (Lhs, const Rhs &)
 
template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs operator/ (Lhs, const Rhs &)
 
template<typename Tp , size_t N>
std::array< Tp, N > operator+ (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
 
template<typename... Types>
std::tuple< Types... > operator+ (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > operator+ (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
 
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > operator+ (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
 
template<typename Tp , size_t N>
std::array< Tp, N > operator- (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
 
template<typename... Types>
std::tuple< Types... > operator- (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > operator- (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
 
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > operator- (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
 
template<typename Tp , size_t N>
std::array< Tp, N > operator* (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
 
template<typename... Types>
std::tuple< Types... > operator* (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > operator* (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
 
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > operator* (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
 
template<typename Tp , size_t N>
std::array< Tp, N > operator/ (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
 
template<typename... Types>
std::tuple< Types... > operator/ (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
 
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > operator/ (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
 
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > operator/ (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
 
template<typename Tp , size_t N, typename OtherT >
std::array< Tp, N > & operator+= (std::array< Tp, N > &lhs, OtherT &&rhs)
 
template<typename Lhs , typename Rhs , typename OtherT >
std::pair< Lhs, Rhs > & operator+= (std::pair< Lhs, Rhs > &lhs, OtherT &&rhs)
 
template<typename Tp , typename... ExtraT, typename OtherT >
std::vector< Tp, ExtraT... > & operator+= (std::vector< Tp, ExtraT... > &lhs, OtherT &&rhs)
 
template<typename... Types, typename OtherT >
std::tuple< Types... > & operator+= (std::tuple< Types... > &lhs, OtherT &&rhs)
 
template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & operator-= (std::vector< Tp, ExtraT... > &lhs, const std::vector< Tp, ExtraT... > &rhs)
 
template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & operator*= (std::vector< Tp, ExtraT... > &lhs, const std::vector< Tp, ExtraT... > &rhs)
 
template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & operator/= (std::vector< Tp, ExtraT... > &lhs, const std::vector< Tp, ExtraT... > &rhs)
 
template<typename Lhs , typename Rhs , typename... ExtraT, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > >
std::vector< Lhs, ExtraT... > & operator*= (std::vector< Lhs, ExtraT... > &lhs, const Rhs &rhs)
 
template<typename Lhs , typename Rhs , typename... ExtraT, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > >
std::vector< Lhs, ExtraT... > & operator/= (std::vector< Lhs, ExtraT... > &lhs, const Rhs &rhs)
 
template<typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::chrono::system_clock::time_point & operator/= (std::chrono::system_clock::time_point &lhs, Rhs)
 

Detailed Description

the namespace is provided to hide stl overload from global namespace but provide a method of using the namespace without a "using namespace tim;"

Function Documentation

◆ operator*() [1/5]

template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs tim::stl::operator* ( Lhs  lhs,
const Rhs &  rhs 
)

Definition at line 295 of file stl.hpp.

296{
297 return (lhs *= rhs);
298}

◆ operator*() [2/5]

template<typename Tp , size_t N>
std::array< Tp, N > tim::stl::operator* ( std::array< Tp, N >  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 410 of file stl.hpp.

411{
412 math::multiply(lhs, rhs);
413 return lhs;
414}
tim::math::multiply
Tp & multiply(Tp &, const Up &)
Definition: multiply.hpp:140

◆ operator*() [3/5]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > tim::stl::operator* ( std::pair< Lhs, Rhs >  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 428 of file stl.hpp.

429{
430 math::multiply(lhs, rhs);
431 return lhs;
432}

◆ operator*() [4/5]

template<typename... Types>
std::tuple< Types... > tim::stl::operator* ( std::tuple< Types... >  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 419 of file stl.hpp.

420{
421 math::multiply(lhs, rhs);
422 return lhs;
423}

◆ operator*() [5/5]

template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > tim::stl::operator* ( std::vector< Tp, Extra... >  lhs,
const std::vector< Tp, Extra... > &  rhs 
)

Definition at line 437 of file stl.hpp.

439{
440 math::multiply(lhs, rhs);
441 return lhs;
442}

◆ operator*=() [1/10]

template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & tim::stl::operator*= ( std::array< Lhs, N > &  lhs,
const Rhs &  rhs 
)

Definition at line 211 of file stl.hpp.

212{
213 math::multiply(lhs, rhs);
214 return lhs;
215}

◆ operator*=() [2/10]

template<typename Tp , size_t N>
std::array< Tp, N > & tim::stl::operator*= ( std::array< Tp, N > &  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 134 of file stl.hpp.

135{
136 math::multiply(lhs, rhs);
137 return lhs;
138}

◆ operator*=() [3/10]

template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & tim::stl::operator*= ( std::pair< Lhs, Rhs > &  lhs,
const ArithT &  rhs 
)

Definition at line 220 of file stl.hpp.

221{
222 math::multiply(lhs, rhs);
223 return lhs;
224}

◆ operator*=() [4/10]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & tim::stl::operator*= ( std::pair< Lhs, Rhs > &  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 142 of file stl.hpp.

143{
144 math::multiply(lhs, rhs);
145 return lhs;
146}

◆ operator*=() [5/10]

template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & tim::stl::operator*= ( std::tuple< Lhs... > &  lhs,
const Rhs &  rhs 
)

Definition at line 238 of file stl.hpp.

239{
240 math::multiply(lhs, rhs);
241 return lhs;
242}

◆ operator*=() [6/10]

template<typename... Types>
std::tuple< Types... > & tim::stl::operator*= ( std::tuple< Types... > &  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 158 of file stl.hpp.

159{
160 math::multiply(lhs, rhs);
161 return lhs;
162}

◆ operator*=() [7/10]

template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & tim::stl::operator*= ( std::vector< Lhs, _Extra... > &  ,
const Rhs &   
)

◆ operator*=() [8/10]

template<typename Lhs , typename Rhs , typename... ExtraT, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > >
std::vector< Lhs, ExtraT... > & tim::stl::operator*= ( std::vector< Lhs, ExtraT... > &  lhs,
const Rhs &  rhs 
)

Definition at line 229 of file stl.hpp.

230{
231 math::multiply(lhs, rhs);
232 return lhs;
233}

◆ operator*=() [9/10]

template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & tim::stl::operator*= ( std::vector< Tp, _Extra... > &  ,
const std::vector< Tp, _Extra... > &   
)

◆ operator*=() [10/10]

template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & tim::stl::operator*= ( std::vector< Tp, ExtraT... > &  lhs,
const std::vector< Tp, ExtraT... > &  rhs 
)

Definition at line 150 of file stl.hpp.

151{
152 math::multiply(lhs, rhs);
153 return lhs;
154}

◆ operator+() [1/4]

template<typename Tp , size_t N>
std::array< Tp, N > tim::stl::operator+ ( std::array< Tp, N >  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 323 of file stl.hpp.

324{
325 math::plus(lhs, rhs);
326 return lhs;
327}
tim::math::plus
Tp & plus(Tp &, const Up &)
Definition: plus.hpp:106

◆ operator+() [2/4]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > tim::stl::operator+ ( std::pair< Lhs, Rhs >  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 343 of file stl.hpp.

344{
345 math::plus(lhs, rhs);
346 return lhs;
347}

◆ operator+() [3/4]

template<typename... Types>
std::tuple< Types... > tim::stl::operator+ ( std::tuple< Types... >  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 333 of file stl.hpp.

334{
335 math::plus(lhs, rhs);
336 return lhs;
337}

◆ operator+() [4/4]

template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > tim::stl::operator+ ( std::vector< Tp, Extra... >  lhs,
const std::vector< Tp, Extra... > &  rhs 
)

Definition at line 353 of file stl.hpp.

354{
355 math::plus(lhs, rhs);
356 return lhs;
357}

◆ operator+=() [1/8]

template<typename Tp , size_t N, typename Other >
std::array< Tp, N > & tim::stl::operator+= ( std::array< Tp, N > &  ,
Other &&   
)

◆ operator+=() [2/8]

template<typename Tp , size_t N, typename OtherT >
std::array< Tp, N > & tim::stl::operator+= ( std::array< Tp, N > &  lhs,
OtherT &&  rhs 
)

Definition at line 58 of file stl.hpp.

59{
60 math::plus(lhs, std::forward<OtherT>(rhs));
61 return lhs;
62}

◆ operator+=() [3/8]

template<typename Lhs , typename Rhs , typename Other >
std::pair< Lhs, Rhs > & tim::stl::operator+= ( std::pair< Lhs, Rhs > &  ,
Other &&   
)

◆ operator+=() [4/8]

template<typename Lhs , typename Rhs , typename OtherT >
std::pair< Lhs, Rhs > & tim::stl::operator+= ( std::pair< Lhs, Rhs > &  lhs,
OtherT &&  rhs 
)

Definition at line 66 of file stl.hpp.

67{
68 math::plus(lhs, std::forward<OtherT>(rhs));
69 return lhs;
70}

◆ operator+=() [5/8]

template<typename... Types, typename Other >
std::tuple< Types... > & tim::stl::operator+= ( std::tuple< Types... > &  ,
Other &&   
)

◆ operator+=() [6/8]

template<typename... Types, typename OtherT >
std::tuple< Types... > & tim::stl::operator+= ( std::tuple< Types... > &  lhs,
OtherT &&  rhs 
)

Definition at line 82 of file stl.hpp.

83{
84 math::plus(lhs, rhs);
85 return lhs;
86}

◆ operator+=() [7/8]

template<typename Tp , typename... _Extra, typename Other >
std::vector< Tp, _Extra... > & tim::stl::operator+= ( std::vector< Tp, _Extra... > &  ,
Other &&   
)

◆ operator+=() [8/8]

template<typename Tp , typename... ExtraT, typename OtherT >
std::vector< Tp, ExtraT... > & tim::stl::operator+= ( std::vector< Tp, ExtraT... > &  lhs,
OtherT &&  rhs 
)

Definition at line 74 of file stl.hpp.

75{
76 math::plus(lhs, std::forward<OtherT>(rhs));
77 return lhs;
78}

◆ operator-() [1/4]

template<typename Tp , size_t N>
std::array< Tp, N > tim::stl::operator- ( std::array< Tp, N >  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 367 of file stl.hpp.

368{
369 math::minus(lhs, rhs);
370 return lhs;
371}
tim::math::minus
Tp & minus(Tp &, const Up &)
Definition: minus.hpp:98

◆ operator-() [2/4]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > tim::stl::operator- ( std::pair< Lhs, Rhs >  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 387 of file stl.hpp.

388{
389 math::minus(lhs, rhs);
390 return lhs;
391}

◆ operator-() [3/4]

template<typename... Types>
std::tuple< Types... > tim::stl::operator- ( std::tuple< Types... >  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 377 of file stl.hpp.

378{
379 math::minus(lhs, rhs);
380 return lhs;
381}

◆ operator-() [4/4]

template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > tim::stl::operator- ( std::vector< Tp, Extra... >  lhs,
const std::vector< Tp, Extra... > &  rhs 
)

Definition at line 397 of file stl.hpp.

398{
399 math::minus(lhs, rhs);
400 return lhs;
401}

◆ operator-=() [1/9]

template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & tim::stl::operator-= ( std::array< Lhs, N > &  ,
const Rhs &   
)

◆ operator-=() [2/9]

template<typename Tp , size_t N>
std::array< Tp, N > & tim::stl::operator-= ( std::array< Tp, N > &  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 96 of file stl.hpp.

97{
98 math::minus(lhs, rhs);
99 return lhs;
100}

◆ operator-=() [3/9]

template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & tim::stl::operator-= ( std::pair< Lhs, Rhs > &  ,
const ArithT &   
)

◆ operator-=() [4/9]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & tim::stl::operator-= ( std::pair< Lhs, Rhs > &  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 104 of file stl.hpp.

105{
106 math::minus(lhs, rhs);
107 return lhs;
108}

◆ operator-=() [5/9]

template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & tim::stl::operator-= ( std::tuple< Lhs... > &  ,
const Rhs &   
)

◆ operator-=() [6/9]

template<typename... Types>
std::tuple< Types... > & tim::stl::operator-= ( std::tuple< Types... > &  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 120 of file stl.hpp.

121{
122 math::minus(lhs, rhs);
123 return lhs;
124}

◆ operator-=() [7/9]

template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & tim::stl::operator-= ( std::vector< Lhs, _Extra... > &  ,
const Rhs &   
)

◆ operator-=() [8/9]

template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & tim::stl::operator-= ( std::vector< Tp, _Extra... > &  ,
const std::vector< Tp, _Extra... > &   
)

◆ operator-=() [9/9]

template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & tim::stl::operator-= ( std::vector< Tp, ExtraT... > &  lhs,
const std::vector< Tp, ExtraT... > &  rhs 
)

Definition at line 112 of file stl.hpp.

113{
114 math::minus(lhs, rhs);
115 return lhs;
116}

◆ operator/() [1/5]

template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs tim::stl::operator/ ( Lhs  lhs,
const Rhs &  rhs 
)

Definition at line 310 of file stl.hpp.

311{
312 return (lhs /= rhs);
313}

◆ operator/() [2/5]

template<typename Tp , size_t N>
std::array< Tp, N > tim::stl::operator/ ( std::array< Tp, N >  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 452 of file stl.hpp.

453{
454 math::divide(lhs, rhs);
455 return lhs;
456}
tim::math::divide
auto divide(Tp &_lhs, Up _rhs, type_list<>,...) -> decltype(_lhs/=_rhs, void())
Definition: divide.hpp:43

◆ operator/() [3/5]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > tim::stl::operator/ ( std::pair< Lhs, Rhs >  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 472 of file stl.hpp.

473{
474 math::divide(lhs, rhs);
475 return lhs;
476}

◆ operator/() [4/5]

template<typename... Types>
std::tuple< Types... > tim::stl::operator/ ( std::tuple< Types... >  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 462 of file stl.hpp.

463{
464 math::divide(lhs, rhs);
465 return lhs;
466}

◆ operator/() [5/5]

template<typename Tp , typename... Extra>
std::vector< Tp, Extra... > tim::stl::operator/ ( std::vector< Tp, Extra... >  lhs,
const std::vector< Tp, Extra... > &  rhs 
)

Definition at line 482 of file stl.hpp.

483{
484 math::divide(lhs, rhs);
485 return lhs;
486}

◆ operator/=() [1/11]

template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > & tim::stl::operator/= ( std::array< Lhs, N > &  lhs,
const Rhs &  rhs 
)

Definition at line 253 of file stl.hpp.

254{
255 math::divide(lhs, rhs);
256 return lhs;
257}

◆ operator/=() [2/11]

template<typename Tp , size_t N>
std::array< Tp, N > & tim::stl::operator/= ( std::array< Tp, N > &  lhs,
const std::array< Tp, N > &  rhs 
)

Definition at line 172 of file stl.hpp.

173{
174 math::divide(lhs, rhs);
175 return lhs;
176}

◆ operator/=() [3/11]

template<typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::chrono::system_clock::time_point & tim::stl::operator/= ( std::chrono::system_clock::time_point &  lhs,
Rhs   
)
inline

Definition at line 302 of file stl.hpp.

303{
304 return lhs;
305}

◆ operator/=() [4/11]

template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > & tim::stl::operator/= ( std::pair< Lhs, Rhs > &  lhs,
const ArithT &  rhs 
)

Definition at line 262 of file stl.hpp.

263{
264 math::divide(lhs, rhs);
265 return lhs;
266}

◆ operator/=() [5/11]

template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > & tim::stl::operator/= ( std::pair< Lhs, Rhs > &  lhs,
const std::pair< Lhs, Rhs > &  rhs 
)

Definition at line 180 of file stl.hpp.

181{
182 math::divide(lhs, rhs);
183 return lhs;
184}

◆ operator/=() [6/11]

template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > & tim::stl::operator/= ( std::tuple< Lhs... > &  lhs,
const Rhs &  rhs 
)

Definition at line 280 of file stl.hpp.

281{
282 math::divide(lhs, rhs);
283 return lhs;
284}

◆ operator/=() [7/11]

template<typename... Types>
std::tuple< Types... > & tim::stl::operator/= ( std::tuple< Types... > &  lhs,
const std::tuple< Types... > &  rhs 
)

Definition at line 196 of file stl.hpp.

197{
198 math::divide(lhs, rhs);
199 return lhs;
200}

◆ operator/=() [8/11]

template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > & tim::stl::operator/= ( std::vector< Lhs, _Extra... > &  ,
const Rhs &   
)

◆ operator/=() [9/11]

template<typename Lhs , typename Rhs , typename... ExtraT, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > >
std::vector< Lhs, ExtraT... > & tim::stl::operator/= ( std::vector< Lhs, ExtraT... > &  lhs,
const Rhs &  rhs 
)

Definition at line 271 of file stl.hpp.

272{
273 math::divide(lhs, rhs);
274 return lhs;
275}

◆ operator/=() [10/11]

template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > & tim::stl::operator/= ( std::vector< Tp, _Extra... > &  ,
const std::vector< Tp, _Extra... > &   
)

◆ operator/=() [11/11]

template<typename Tp , typename... ExtraT>
std::vector< Tp, ExtraT... > & tim::stl::operator/= ( std::vector< Tp, ExtraT... > &  lhs,
const std::vector< Tp, ExtraT... > &  rhs 
)

Definition at line 188 of file stl.hpp.

189{
190 math::divide(lhs, rhs);
191 return lhs;
192}