math/require__generics_8hpp_source.html

#ifndef STAN_MATH_PRIM_META_REQUIRE_GENERICS_HPP

#define STAN_MATH_PRIM_META_REQUIRE_GENERICS_HPP


#include <stan/math/prim/meta/require_helpers.hpp>

#include <type_traits>


namespace stan {


template <typename T, typename S>

using require_same_t

    = require_t<std::is_same<std::decay_t<T>, std::decay_t<S>>>;


template <typename T, typename S>

using require_not_same_t

    = require_not_t<std::is_same<std::decay_t<T>, std::decay_t<S>>>;


template <typename T, typename... Types>

using require_all_same_t

    = require_all_t<std::is_same<std::decay_t<T>, std::decay_t<Types>>...>;


template <typename T, typename... Types>

using require_any_same_t

    = require_any_t<std::is_same<std::decay_t<T>, std::decay_t<Types>>...>;


template <typename T, typename... Types>

using require_all_not_same_t

    = require_all_not_t<std::is_same<std::decay_t<T>, std::decay_t<Types>>...>;


template <typename T, typename... Types>

using require_any_not_same_t

    = require_any_not_t<std::is_same<std::decay_t<T>, std::decay_t<Types>>...>;

template <typename T, typename S>

using require_st_same = require_t<std::is_same<scalar_type_t<std::decay_t<T>>,

                                               scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename S>

using require_not_st_same

    = require_not_t<std::is_same<scalar_type_t<std::decay_t<T>>,

                                 scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_st_same

    = require_all_t<std::is_same<scalar_type_t<std::decay_t<T>>,

                                 scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_not_st_same

    = require_any_not_t<std::is_same<scalar_type_t<std::decay_t<T>>,

                                     scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename S>

using require_vt_same = require_t<

    std::is_same<value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_vt_same

    = require_all_t<std::is_same<value_type_t<std::decay_t<T>>,

                                 value_type_t<std::decay_t<Types>>>...>;

template <typename T, typename S>

using require_convertible_t

    = require_t<std::is_convertible<std::decay_t<T>, std::decay_t<S>>>;


template <typename T, typename S>

using require_not_convertible_t

    = require_not_t<std::is_convertible<std::decay_t<T>, std::decay_t<S>>>;


template <typename T, typename... Types>

using require_all_convertible_t = require_all_t<

    std::is_convertible<std::decay_t<T>, std::decay_t<Types>>...>;


template <typename T, typename... Types>

using require_any_not_convertible_t = require_any_not_t<

    std::is_convertible<std::decay_t<T>, std::decay_t<Types>>...>;

template <typename T, typename S>

using require_assignable_t

    = require_t<std::is_assignable<std::decay_t<T>, std::decay_t<S>>>;


template <typename T, typename S>

using require_not_assignable_t

    = require_not_t<std::is_assignable<std::decay_t<T>, std::decay_t<S>>>;

template <typename T, typename S>

using require_st_assignable

    = require_t<std::is_assignable<scalar_type_t<std::decay_t<T>>,

                                   scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename S>

using require_not_st_assignable

    = require_not_t<std::is_assignable<scalar_type_t<std::decay_t<T>>,

                                       scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_st_assignable

    = require_all_t<std::is_assignable<scalar_type_t<std::decay_t<T>>,

                                       scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_st_assignable

    = require_any_t<std::is_assignable<scalar_type_t<std::decay_t<T>>,

                                       scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_all_not_st_assignable = require_all_not_t<std::is_assignable<

    scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_not_st_assignable = require_any_not_t<std::is_assignable<

    scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename S>

using require_vt_assignable

    = require_t<std::is_assignable<value_type_t<std::decay_t<T>>,

                                   value_type_t<std::decay_t<S>>>>;


template <typename T, typename S>

using require_not_vt_assignable

    = require_not_t<std::is_assignable<value_type_t<std::decay_t<T>>,

                                       value_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_vt_assignable

    = require_all_t<std::is_assignable<value_type_t<std::decay_t<T>>,

                                       value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_vt_assignable

    = require_any_t<std::is_assignable<value_type_t<std::decay_t<T>>,

                                       value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_all_not_vt_assignable = require_all_not_t<std::is_assignable<

    value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_not_vt_assignable = require_any_not_t<std::is_assignable<

    value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;

template <typename T, typename S>

using require_constructible_t

    = require_t<std::is_constructible<std::decay_t<T>, std::decay_t<S>>>;

template <typename T, typename S>

using require_st_constructible

    = require_t<std::is_constructible<scalar_type_t<std::decay_t<T>>,

                                      scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename S>

using require_not_st_constructible

    = require_not_t<std::is_constructible<scalar_type_t<std::decay_t<T>>,

                                          scalar_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_st_constructible = require_all_t<std::is_constructible<

    scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_st_constructible = require_any_t<std::is_constructible<

    scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_all_not_st_constructible

    = require_all_not_t<std::is_constructible<

        scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_not_st_constructible

    = require_any_not_t<std::is_constructible<

        scalar_type_t<std::decay_t<T>>, scalar_type_t<std::decay_t<Types>>>...>;


template <typename T, typename S>

using require_vt_constructible

    = require_t<std::is_constructible<value_type_t<std::decay_t<T>>,

                                      value_type_t<std::decay_t<S>>>>;


template <typename T, typename S>

using require_not_vt_constructible

    = require_not_t<std::is_constructible<value_type_t<std::decay_t<T>>,

                                          value_type_t<std::decay_t<S>>>>;


template <typename T, typename... Types>

using require_all_vt_constructible = require_all_t<std::is_constructible<

    value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_vt_constructible = require_any_t<std::is_constructible<

    value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_all_not_vt_constructible

    = require_all_not_t<std::is_constructible<

        value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;


template <typename T, typename... Types>

using require_any_not_vt_constructible

    = require_any_not_t<std::is_constructible<

        value_type_t<std::decay_t<T>>, value_type_t<std::decay_t<Types>>>...>;

template <typename T>

using require_arithmetic_t = require_t<std::is_arithmetic<std::decay_t<T>>>;


template <typename T>

using require_not_arithmetic_t

    = require_not_t<std::is_arithmetic<std::decay_t<T>>>;


template <typename... Types>

using require_all_arithmetic_t

    = require_all_t<std::is_arithmetic<std::decay_t<Types>>...>;


template <typename... Types>

using require_any_arithmetic_t

    = require_any_t<std::is_arithmetic<std::decay_t<Types>>...>;


template <typename... Types>

using require_all_not_arithmetic_t

    = require_all_not_t<std::is_arithmetic<std::decay_t<Types>>...>;


template <typename... Types>

using require_any_not_arithmetic_t

    = require_any_not_t<std::is_arithmetic<std::decay_t<Types>>...>;

template <typename... Types>

using require_all_vt_arithmetic

    = require_all_t<std::is_arithmetic<value_type_t<std::decay_t<Types>>>...>;


template <typename... Types>

using require_any_not_vt_arithmetic = require_any_not_t<

    std::is_arithmetic<value_type_t<std::decay_t<Types>>>...>;


template <typename T>

using require_st_arithmetic

    = require_t<std::is_arithmetic<scalar_type_t<std::decay_t<T>>>>;


template <typename T>

using require_not_st_arithmetic

    = require_not_t<std::is_arithmetic<scalar_type_t<std::decay_t<T>>>>;


template <typename... Types>

using require_all_st_arithmetic

    = require_all_t<std::is_arithmetic<scalar_type_t<std::decay_t<Types>>>...>;


template <typename... Types>

using require_any_st_arithmetic

    = require_any_t<std::is_arithmetic<scalar_type_t<std::decay_t<Types>>>...>;


template <typename... Types>

using require_any_not_st_arithmetic = require_any_not_t<

    std::is_arithmetic<scalar_type_t<std::decay_t<Types>>>...>;

template <typename T>

using require_floating_point_t

    = require_t<std::is_floating_point<std::decay_t<T>>>;

template <typename T>

using require_integral_t = require_t<std::is_integral<std::decay_t<T>>>;

template <typename T>

using require_vt_integral

    = require_t<std::is_integral<value_type_t<std::decay_t<T>>>>;


template <typename T>

using require_st_integral

    = require_t<std::is_integral<scalar_type_t<std::decay_t<T>>>>;


template <typename T>

using require_not_st_integral

    = require_not_t<std::is_integral<scalar_type_t<std::decay_t<T>>>>;


template <typename... Types>

using require_all_not_st_integral = require_all_not_t<

    std::is_integral<scalar_type_t<std::decay_t<Types>>>...>;

}  // namespace stan

#endif

stan::require_all_arithmetic_t
require_all_t< std::is_arithmetic< std::decay_t< Types > >... > require_all_arithmetic_t
Require all of the types satisfy std::is_arithmetic.
Definition require_generics.hpp:322

stan::require_arithmetic_t
require_t< std::is_arithmetic< std::decay_t< T > > > require_arithmetic_t
Require type satisfies std::is_arithmetic.
Definition require_generics.hpp:312

stan::require_all_st_arithmetic
require_all_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... > require_all_st_arithmetic
Require all of the scalar types satisfy std::is_arithmetic.
Definition require_generics.hpp:369

stan::require_any_st_arithmetic
require_any_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... > require_any_st_arithmetic
Require any of the scalar types satisfy std::is_arithmetic.
Definition require_generics.hpp:374

stan::require_not_arithmetic_t
require_not_t< std::is_arithmetic< std::decay_t< T > > > require_not_arithmetic_t
Require type does not satisfy std::is_arithmetic.
Definition require_generics.hpp:317

stan::require_not_st_arithmetic
require_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > > require_not_st_arithmetic
Require scalar type does not satisfy std::is_arithmetic.
Definition require_generics.hpp:364

stan::require_any_not_st_arithmetic
require_any_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... > require_any_not_st_arithmetic
Any of the scalar types do not satisfy std::is_arithmetic.
Definition require_generics.hpp:379

stan::require_any_arithmetic_t
require_any_t< std::is_arithmetic< std::decay_t< Types > >... > require_any_arithmetic_t
Require any of the types satisfy std::is_arithmetic.
Definition require_generics.hpp:327

stan::require_any_not_vt_arithmetic
require_any_not_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... > require_any_not_vt_arithmetic
Require at least one of the value types do not satisfy std::is_arithmetic.
Definition require_generics.hpp:354

stan::require_st_arithmetic
require_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > > require_st_arithmetic
Require scalar type satisfies std::is_arithmetic.
Definition require_generics.hpp:359

stan::require_all_not_arithmetic_t
require_all_not_t< std::is_arithmetic< std::decay_t< Types > >... > require_all_not_arithmetic_t
Require none of the types satisfy std::is_arithmetic.
Definition require_generics.hpp:332

stan::require_all_vt_arithmetic
require_all_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... > require_all_vt_arithmetic
Require all of the value types satisfy std::is_arithmetic.
Definition require_generics.hpp:348

stan::require_any_not_arithmetic_t
require_any_not_t< std::is_arithmetic< std::decay_t< Types > >... > require_any_not_arithmetic_t
Require at least one of the types do not satisfy std::is_arithmetic.
Definition require_generics.hpp:338

stan::require_all_st_assignable
require_all_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_all_st_assignable
All scalar types of T and all of the Types satisfy std::is_assignable.
Definition require_generics.hpp:151

stan::require_assignable_t
require_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > > require_assignable_t
Require types T and S satisfies std::is_assignable.
Definition require_generics.hpp:120

stan::require_vt_assignable
require_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > > require_vt_assignable
Value types of T and S satisfies std::is_assignable.
Definition require_generics.hpp:176

stan::require_all_not_st_assignable
require_all_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_all_not_st_assignable
None of the scalar types of Types and T satisfy std::is_assignable.
Definition require_generics.hpp:164

stan::require_any_not_st_assignable
require_any_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_any_not_st_assignable
Any of the scalar types Types and T do not satisfy std::is_assignable.
Definition require_generics.hpp:170

stan::require_st_assignable
require_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_st_assignable
Require that value types of T and S satisfies std::is_assignable.
Definition require_generics.hpp:137

stan::require_any_st_assignable
require_any_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_any_st_assignable
Any of the scalar types of Types and T satisfy std::is_assignable.
Definition require_generics.hpp:158

stan::require_all_vt_assignable
require_all_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_all_vt_assignable
Value types of T and all of the Types satisfy std::is_assignable.
Definition require_generics.hpp:189

stan::require_not_st_assignable
require_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_not_st_assignable
Require scalar types of T and S does not satisfy std::is_assignable.
Definition require_generics.hpp:144

stan::require_not_assignable_t
require_not_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > > require_not_assignable_t
Require types T and S does not satisfy std::is_assignable.
Definition require_generics.hpp:125

stan::require_all_not_vt_assignable
require_all_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_all_not_vt_assignable
None of the value types of Types and T satisfy std::is_assignable.
Definition require_generics.hpp:202

stan::require_any_not_vt_assignable
require_any_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_any_not_vt_assignable
Any of the value types Types and T do not satisfy std::is_assignable.
Definition require_generics.hpp:208

stan::require_any_vt_assignable
require_any_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_any_vt_assignable
Any of the value types of Types and T satisfy std::is_assignable.
Definition require_generics.hpp:196

stan::require_not_vt_assignable
require_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > > require_not_vt_assignable
Value types of T and S does not satisfy std::is_assignable.
Definition require_generics.hpp:182

stan::require_all_not_st_constructible
require_all_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_all_not_st_constructible
None of the scalar types of Types and T satisfy std::is_constructible.
Definition require_generics.hpp:257

stan::require_any_not_vt_constructible
require_any_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_any_not_vt_constructible
Any of the value types Types and T do not satisfy std::is_constructible.
Definition require_generics.hpp:302

stan::require_not_st_constructible
require_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_not_st_constructible
Require scalar types of T and S does not satisfy std::is_constructible.
Definition require_generics.hpp:238

stan::require_all_vt_constructible
require_all_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_all_vt_constructible
Value types of T and all of the Types satisfy std::is_constructible.
Definition require_generics.hpp:282

stan::require_any_vt_constructible
require_any_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_any_vt_constructible
Any of the value types of Types and T satisfy std::is_constructible.
Definition require_generics.hpp:288

stan::require_all_not_vt_constructible
require_all_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_all_not_vt_constructible
None of the value types of Types and T satisfy std::is_constructible.
Definition require_generics.hpp:295

stan::require_not_vt_constructible
require_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > > require_not_vt_constructible
Value types of T and S does not satisfy std::is_constructible.
Definition require_generics.hpp:276

stan::require_all_st_constructible
require_all_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_all_st_constructible
All scalar types of T and all of the Types satisfy std::is_constructible.
Definition require_generics.hpp:244

stan::require_vt_constructible
require_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > > require_vt_constructible
Value types of T and S satisfies std::is_constructible.
Definition require_generics.hpp:270

stan::require_constructible_t
require_t< std::is_constructible< std::decay_t< T >, std::decay_t< S > > > require_constructible_t
Require types T and S satisfies std::is_constructible.
Definition require_generics.hpp:219

stan::require_any_not_st_constructible
require_any_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_any_not_st_constructible
Any of the scalar types Types and T do not satisfy std::is_constructible.
Definition require_generics.hpp:264

stan::require_st_constructible
require_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_st_constructible
Require that value types of T and S satisfies std::is_constructible.
Definition require_generics.hpp:231

stan::require_any_st_constructible
require_any_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_any_st_constructible
Any of the scalar types of Types and T satisfy std::is_constructible.
Definition require_generics.hpp:250

stan::require_not_convertible_t
require_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > > require_not_convertible_t
Require types T and S does not satisfy std::is_convertible.
Definition require_generics.hpp:99

stan::require_convertible_t
require_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > > require_convertible_t
Require types T and S satisfies std::is_convertible.
Definition require_generics.hpp:94

stan::require_any_not_convertible_t
require_any_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... > require_any_not_convertible_t
Any one of the Types and T do not satisfy.
Definition require_generics.hpp:109

stan::require_all_convertible_t
require_all_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... > require_all_convertible_t
Require T and all of the Types satisfy std::is_convertible.
Definition require_generics.hpp:104

stan::require_floating_point_t
require_t< std::is_floating_point< std::decay_t< T > > > require_floating_point_t
Require type satisfies std::is_floating_point.
Definition require_generics.hpp:390

stan::require_all_not_st_integral
require_all_not_t< std::is_integral< scalar_type_t< std::decay_t< Types > > >... > require_all_not_st_integral
Require none of the scalar types satisfy std::is_integral.
Definition require_generics.hpp:425

stan::require_integral_t
require_t< std::is_integral< std::decay_t< T > > > require_integral_t
Require type satisfies std::is_integral.
Definition require_generics.hpp:400

stan::require_vt_integral
require_t< std::is_integral< value_type_t< std::decay_t< T > > > > require_vt_integral
Require value type satisfies std::is_integral.
Definition require_generics.hpp:410

stan::require_not_st_integral
require_not_t< std::is_integral< scalar_type_t< std::decay_t< T > > > > require_not_st_integral
Require scalar type does not satisfy std::is_integral.
Definition require_generics.hpp:420

stan::require_st_integral
require_t< std::is_integral< scalar_type_t< std::decay_t< T > > > > require_st_integral
Require scalar type satisfies std::is_integral.
Definition require_generics.hpp:415

stan::require_all_st_same
require_all_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_all_st_same
All scalar types of T and all of the Types satisfy std::is_same.
Definition require_generics.hpp:65

stan::require_st_same
require_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_st_same
Require that value types of T and S satisfies std::is_same.
Definition require_generics.hpp:52

stan::require_not_same_t
require_not_t< std::is_same< std::decay_t< T >, std::decay_t< S > > > require_not_same_t
Require types T and S does not satisfy std::is_same.
Definition require_generics.hpp:22

stan::require_all_same_t
require_all_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... > require_all_same_t
Require T and all of the Types satisfy std::is_same.
Definition require_generics.hpp:27

stan::require_same_t
require_t< std::is_same< std::decay_t< T >, std::decay_t< S > > > require_same_t
Require types T and S satisfies std::is_same.
Definition require_generics.hpp:17

stan::require_not_st_same
require_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > > require_not_st_same
Require scalar types of T and S does not satisfy std::is_same.
Definition require_generics.hpp:58

stan::require_all_not_same_t
require_all_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... > require_all_not_same_t
Require none of the Types and T satisfy std::is_same.
Definition require_generics.hpp:37

stan::require_any_not_same_t
require_any_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... > require_any_not_same_t
Any one of the Types and T do not satisfy std::is_same.
Definition require_generics.hpp:42

stan::require_any_same_t
require_any_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... > require_any_same_t
Require any of the Types and T satisfy std::is_same.
Definition require_generics.hpp:32

stan::require_any_not_st_same
require_any_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... > require_any_not_st_same
Any of the scalar types Types and T do not satisfy std::is_same.
Definition require_generics.hpp:72

stan::require_vt_same
require_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > > require_vt_same
Value types of T and S satisfies std::is_same.
Definition require_generics.hpp:77

stan::require_all_vt_same
require_all_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... > require_all_vt_same
Value types of T and all of the Types satisfy std::is_same.
Definition require_generics.hpp:83

stan::value_type_t
typename value_type< T >::type value_type_t
Helper function for accessing underlying type.
Definition value_type.hpp:35

stan::require_not_t
std::enable_if_t<!Check::value > require_not_t
If condition is false, template is disabled.
Definition require_helpers.hpp:26

stan::require_any_t
std::enable_if_t< math::disjunction< Checks... >::value > require_any_t
If any condition is true, template is enabled.
Definition require_helpers.hpp:43

stan::require_all_not_t
std::enable_if_t<!math::disjunction< Checks... >::value > require_all_not_t
If all conditions are false, template is enabled.
Definition require_helpers.hpp:53

stan::scalar_type_t
typename scalar_type< T >::type scalar_type_t
Definition scalar_type.hpp:25

stan::require_any_not_t
std::enable_if_t<!math::conjunction< Checks... >::value > require_any_not_t
If any condition is false, template is enabled.
Definition require_helpers.hpp:63

stan::require_t
std::enable_if_t< Check::value > require_t
If condition is true, template is enabled.
Definition require_helpers.hpp:19

stan::require_all_t
std::enable_if_t< math::conjunction< Checks... >::value > require_all_t
If all conditions are true, template is enabled Returns a type void if all conditions are true and ot...
Definition require_helpers.hpp:34

stan
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
Definition unit_vector_constrain.hpp:15

require_helpers.hpp