Random number generator; built on top of Drjit. More...

Classes
struct	add_diff_t

struct	add_packet_t

struct	array

struct	array< T, N >

struct	complex
	Complex numbers. More...

struct	rng
	Random generator wrapper around Drjit's PCG32. More...

struct	rng< T >
	Integral specialization. More...

Typedefs
template<typename T >
using	color = drjit::Array< T, 3 >

template<typename T >
using	complex = drjit::Complex< T >
	Alias drjit::Complex.

using	seed_t = uint64_t
	seed type

template<typename T >
using	add_diff_t = typename detail::add_diff< std::decay_t< T > >::type
	Add autodiff to type T.

template<typename T >
using	add_packet_t = typename detail::add_packet< std::decay_t< T > >::type
	Add packet to type T.

template<typename T >
using	vec2d = drjit::Array< T, 2 >

template<typename T >
using	vec3d = drjit::Array< T, 3 >

template<typename... T>
using	result_t = typename detail::result_impl< T... >::type
	determine the mathematical result type; reverts to first argument if '+' is not defined on T...

Functions
template<typename T >
remove_diff_t< T > &	detach_gradient (T &)

template<typename T >
void	track_gradient (T &, bool)

template<typename T >
bool	is_gradient_tracked (T &)

template<typename T >
const remove_diff_t< T > &	gradient (T &)

template<typename T >
void	forward_gradient (T &)

template<typename T >
void	backward_gradient (T &)

template<typename T > requires false
std::string	toString (const T &)
	regular drjit::array types

template<typename T > requires false
T	fromString (const std::string &)

template<typename T , typename U >
auto	atan2 (drjit::Complex< T > a, drjit::Complex< U > b)=delete
	delete atan2 to avoid static_error

template<typename NEWTYPE , typename OLDTYPE >
NEWTYPE	cast (OLDTYPE &&val)
	cast

template<typename MASK , typename A , typename B >
auto	select (MASK &&mask, A &&a, B &&b)
	Extension of drjit::select to diff/non-diff masks.

template<typename RET , typename C , typename Index > requires (!is_packet_v<Index>) && std::ranges::range<C> && std::convertible_to<bbm::iterable_value_t<C>, RET> && is_index_v<Index>
constexpr RET	lookup (C &&container, const Index &idx, const index_mask_t< Index > &mask=true)
	Non-packet look up.

template<typename VAL , typename C , typename Index > requires (!is_packet_v<Index>) && std::ranges::range<C> && is_index_v<Index> && std::convertible_to<VAL, bbm::iterable_value_t<C>>
constexpr void	set (C &&container, const Index &idx, VAL &&value, const index_mask_t< Index > &mask=true)
	Non-packet set.

template<typename C , typename PRED > requires std::ranges::range<C> && std::is_invocable_r_v<mask_t<bbm::iterable_value_t<C>>, PRED, bbm::iterable_value_t<C>>
constexpr index_t< bbm::iterable_value_t< C > >	binary_search (C &&container, PRED &&predicate, const index_mask_t< bbm::iterable_value_t< C > > &mask=true)
	binary search

template<typename T , typename U >
auto	max (T &&t, U &&u)
	max between two variables

template<typename T , typename U >
auto	min (T &&t, U &&u)
	min between two variables

template<typename T >
T	erfc (const T &t)
	erfc

template<typename T >
vec2d< T >	cossin (const T &a)
	cossin

template<typename T > requires (drjit::is_static_array_v<T> && !backbone::is_LLVMArray_v<T> && !backbone::is_DiffArray_v<T>)
std::string	toString (const T &arr)
	regular drjit::array types

template<typename T > requires (drjit::is_static_array_v<T> && !backbone::is_LLVMArray_v<T> && !backbone::is_DiffArray_v<T>)
T	fromString (const std::string &str)

template<typename T > requires backbone::is_DiffArray_v<T>
std::string	toString (const T &val)
	Handle drjit::DiffArray.

template<typename T > requires backbone::is_DiffArray_v<T>
T	fromString (const std::string &str)

template<typename T > requires backbone::is_LLVMArray_v<T>
std::string	toString (const T &val)
	Handle drjit::LLVMArray.

template<typename T > requires backbone::is_LLVMArray_v<T>
T	fromString (const std::string &str)

template<typename RET , typename C , typename Index > requires is_packet_v<RET> && is_packet_v<Index> && std::ranges::range<C> && is_index_v<Index> && std::convertible_to<bbm::iterable_value_t<C>, remove_packet_t<RET>> && (!is_packet_v<bbm::iterable_value_t<C>>)
RET	lookup (C &&container, const Index &idx, const index_mask_t< Index > &mask=true)
	Non-packet data, Packet look up.

template<typename RET , typename C , typename Index > requires is_packet_v<RET> && is_packet_v<Index> && std::ranges::range<C> && is_index_v<Index> && std::convertible_to<bbm::iterable_value_t<C>, RET> && is_packet_v<bbm::iterable_value_t<C>>
RET	lookup (C &&container, const Index &idx, const index_mask_t< Index > &mask=true)
	Packet data, Packet look up.

template<typename VAL , typename C , typename Index > requires is_packet_v<VAL> && is_packet_v<Index> && std::ranges::range<C> && is_index_v<Index> && std::convertible_to<remove_packet_t<VAL>, bbm::iterable_value_t<C>> && (!is_packet_v<bbm::iterable_value_t<C>>)
void	set (C &&container, const Index &idx, VAL &&value, const index_mask_t< Index > &mask=true)
	Non-packet data, Packet set.

template<typename VAL , typename C , typename Index > requires is_packet_v<VAL> && is_packet_v<Index> && std::ranges::range<C> && is_index_v<Index> && std::convertible_to<VAL, bbm::iterable_value_t<C>> && is_packet_v<bbm::iterable_value_t<C>>
void	set (C &&container, const Index &idx, VAL &&value, const index_mask_t< Index > &mask=true)
	Packet data, Packet set.

template<typename T > requires (enoki::is_static_array_v<T> && !backbone::is_DiffArray_v<T>)
std::string	toString (const T &arr)
	regular enoki::array types

template<typename T > requires (enoki::is_static_array_v<T> && !backbone::is_DiffArray_v<T>)
T	fromString (const std::string &str)

template<typename T >
constexpr complex< T >	rcp (complex< T > z)
	rcp

template<typename T >
constexpr vec2d< complex< T > >	cossin (complex< T > z)
	cossin method

template<typename NEWTYPE , typename OLDTYPE >
constexpr NEWTYPE	cast (OLDTYPE &&val)
	cast

template<typename RET , typename C > requires std::ranges::range<C> && std::convertible_to<bbm::iterable_value_t<C>, RET>
constexpr RET	lookup (C &&container, size_t idx, bool mask=true)
	lookup

template<typename VAL , typename C > requires std::ranges::range<C> && std::convertible_to<VAL, bbm::iterable_value_t<C>>
constexpr void	set (C &&container, size_t idx, VAL &&value, bool mask=true)
	set

template<typename C , typename PRED > requires std::ranges::range<C> && std::is_invocable_r_v<bool, PRED, bbm::iterable_value_t<C>>
constexpr size_t	binary_search (C &&container, PRED &&predicate, bool mask=true)
	binary_search

template<typename T > requires backbone::is_array_v<T>
std::string	toString (const T &arr)
	regular drjit::array types

template<typename T > requires backbone::is_array_v<T>
T	fromString (const std::string &str)


template<typename T >
auto	dot (const T &a, const T &b)

template<typename T >
auto	norm (const T &a)

template<typename T >
auto	squared_norm (const T &a)

template<typename T >
auto	normalize (const T &a)

Passthough to DrJIT (name change)
template<typename T >
auto	hsum (const T &t)

template<typename T >
auto	hprod (const T &t)

template<typename T >
auto	hmax (const T &t)

template<typename T >
auto	hmin (const T &t)

Map math operations to Enoki functions
	BBM_ENOKI_MATHOP (exp)

	BBM_ENOKI_MATHOP (log)

	BBM_ENOKI_MATHOP (sin)

	BBM_ENOKI_MATHOP (asin)

	BBM_ENOKI_MATHOP (cos)

	BBM_ENOKI_MATHOP (acos)

	BBM_ENOKI_MATHOP (tan)

	BBM_ENOKI_MATHOP (atan)

	BBM_ENOKI_MATHOP (atan2)

	BBM_ENOKI_MATHOP (sinh)

	BBM_ENOKI_MATHOP (asinh)

	BBM_ENOKI_MATHOP (cosh)

	BBM_ENOKI_MATHOP (acosh)

	BBM_ENOKI_MATHOP (tanh)

	BBM_ENOKI_MATHOP (atanh)

	BBM_ENOKI_MATHOP (ceil)

	BBM_ENOKI_MATHOP (floor)

	BBM_ENOKI_MATHOP (round)

	BBM_ENOKI_MATHOP (clamp)

	BBM_ENOKI_MATHOP (fmod)

	BBM_ENOKI_MATHOP (copysign)

	BBM_ENOKI_MATHOP (sign)

	BBM_ENOKI_MATHOP (lerp)

	BBM_ENOKI_MATHOP (abs)

	BBM_ENOKI_MATHOP (sqrt)

	BBM_ENOKI_MATHOP (cbrt)

	BBM_ENOKI_MATHOP (pow)

	BBM_ENOKI_MATHOP (max)

	BBM_ENOKI_MATHOP (min)

	BBM_ENOKI_MATHOP (safe_sqrt)

	BBM_ENOKI_MATHOP (safe_asin)

	BBM_ENOKI_MATHOP (safe_acos)

	BBM_ENOKI_MATHOP (erf)

	BBM_ENOKI_MATHOP (erfc)

	BBM_ENOKI_MATHOP (erfinv)

	BBM_ENOKI_MATHOP (tgamma)

	BBM_ENOKI_MATHOP (lgamma)

	BBM_ENOKI_MATHOP (eq)

	BBM_ENOKI_MATHOP (neq)

	BBM_ENOKI_MATHOP (rcp)

	BBM_ENOKI_MATHOP (rsqrt)

	BBM_ENOKI_MATHOP (isnan)

	BBM_ENOKI_MATHOP (isinf)

	BBM_ENOKI_MATHOP (isfinite)

Core Inspectors
template<typename T >
constexpr T	real (complex< T > z)

template<typename T >
constexpr T	imag (complex< T > z)

template<typename T >
constexpr complex< T >	conj (complex< T > z)

std::complex -> complex Functions
	BBM_DECL_COMPLEX_OP (exp)

	BBM_DECL_COMPLEX_OP (log)

	BBM_DECL_COMPLEX_OP (pow)

	BBM_DECL_COMPLEX_OP (sqrt)

	BBM_DECL_COMPLEX_OP (sin)

	BBM_DECL_COMPLEX_OP (cos)

	BBM_DECL_COMPLEX_OP (tan)

	BBM_DECL_COMPLEX_OP (asin)

	BBM_DECL_COMPLEX_OP (acos)

	BBM_DECL_COMPLEX_OP (atan)

	BBM_DECL_COMPLEX_OP (sinh)

	BBM_DECL_COMPLEX_OP (cosh)

	BBM_DECL_COMPLEX_OP (tanh)

	BBM_DECL_COMPLEX_OP (asinh)

	BBM_DECL_COMPLEX_OP (acosh)

	BBM_DECL_COMPLEX_OP (atanh)

Horizontal methods
template<typename T >
constexpr complex< T >	reverse (complex< T > z)

template<typename T >
constexpr complex< T >	psum (complex< T > z)

template<typename T >
constexpr complex< T >	normalize (complex< T > z)

select
template<typename T , typename U > requires requires(std::decay_t<T> a, std::decay_t<U> b) {{a+b};}
constexpr auto	select (bool mask, const T &a, const U &b)

template<typename T , typename U , size_t N> requires requires(value_t<T> a, value_t<U> b) {{a+b};}
constexpr auto	select (const array< bool, N > &mask, const T &a, const U &b)

template<typename T , typename U > requires (!is_complex_v<U>) && requires(value_t<T> a, value_t<U> b) {{a+b};}
constexpr auto	select (const array< bool, 2 > &mask, const complex< T > &z, const U &u)

template<typename T , typename U > requires (!is_complex_v<U>) && requires(value_t<T> a, value_t<U> b) {{a+b};}
constexpr auto	select (const array< bool, 2 > &mask, const U &u, const complex< T > &z)

Horizontal operations on scalars
template<typename T > requires std::is_scalar_v<T>
T	hsum (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	hprod (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	hmax (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	hmin (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	dot (const T &a, const T &b)

template<typename T > requires std::is_scalar_v<T>
T	norm (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	squared_norm (const T &t)

template<typename T > requires std::is_scalar_v<T>
T	normalize (const T &)

Mask operations on scalars
template<typename T > requires std::convertible_to<T, bool>
bool	all (const T &t)

template<typename T > requires std::convertible_to<T, bool>
bool	any (const T &t)

template<typename T > requires std::convertible_to<T, bool>
bool	none (const T &t)

template<typename T > requires std::convertible_to<T, bool>
size_t	count (const T &t)

Horizontal operations on arrays
template<typename T , size_t N>
auto	hsum (const array< T, N > &t)

template<typename T , size_t N>
auto	hprod (const array< T, N > &t)

template<typename T , size_t N>
auto	hmax (const array< T, N > &t)

template<typename T , size_t N>
auto	hmin (const array< T, N > &t)

template<typename T , typename U , size_t N>
auto	dot (const array< T, N > &a, const array< U, N > &b)

template<typename T , size_t N>
auto	squared_norm (const array< T, N > &t)

template<typename T , size_t N>
auto	norm (const array< T, N > &t)

template<typename T , size_t N>
auto	normalize (const array< T, N > &t)

template<size_t N>
bool	all (const array< bool, N > &t)
	\Name Mask operations on arrays

template<size_t N>
bool	any (const array< bool, N > &t)

template<size_t N>
bool	none (const array< bool, N > &t)

template<size_t N>
size_t	count (const array< bool, N > &t)

STL math extensions
template<typename T , typename U > requires (!is_array_v<T>) && requires(T a, U b) { { std::atan2(result_t<T, U>(a), result_t<T,U>(b)) }; }
constexpr auto	atan2 (T a, U b)

template<typename T , typename U > requires (!is_array_v<T>) && requires(T a, U b) { { std::fmod(result_t<T, U>(a), result_t<T,U>(b)) }; }
constexpr auto	fmod (T a, U b)

template<typename T , typename U , typename V > requires (!is_array_v<T>) && requires(T a, U b, V c) { { std::lerp(result_t<T, U, V>(a), result_t<T,U,V>(b), result_t<T,U,V>(c)) }; }
constexpr auto	lerp (T a, U b, V c)

template<typename T , typename U > requires (!is_array_v<T>) && requires(T a, U b) { { std::pow(result_t<T, U>(a), result_t<T,U>(b)) }; }
constexpr auto	pow (T a, U b)

template<typename T , typename U > requires (!is_array_v<T>) && requires(T a, U b) { { std::fmax(result_t<T,U>(a), result_t<T,U>(b)) }; }
constexpr auto	max (T a, U b)

template<typename T , typename U > requires (!is_array_v<T>) && requires(T a, U b) { { std::fmin(result_t<T,U>(a), result_t<T,U>(b)) }; }
constexpr auto	min (T a, U b)

template<typename T , typename L , typename U > requires (!is_array_v<T>) && requires(const T& a, const L& l, const U& u) { { std::clamp(a, T(l), T(u)) }; }
constexpr auto	clamp (const T &a, const L &l, const U &u)

template<typename T >
constexpr auto	rcp (T a)

template<typename T > requires requires(const T& a) {{std::sqrt(a)};}
constexpr auto	rsqrt (T a)

template<typename T > requires requires(const T& a) {{std::log(a)};}
constexpr auto	erfinv (T a)

template<typename T > requires requires(T a) { { std::copysign(T(1), a) }; }
constexpr auto	sign (T a)

template<typename T > requires requires(T a) { { std::cos(a) }; { std::sin(a) }; }
constexpr vec2d< T >	cossin (T a)

template<typename T > requires requires(T a) { { std::sqrt(std::fmax(a,T(0))) }; }
constexpr auto	safe_sqrt (T a)

template<typename T > requires requires(T a) { { std::asin(std::fmin(T(1), std::fmax(T(-1), a))) }; }
constexpr auto	safe_asin (T a)

template<typename T > requires requires(T a) { { std::acos(std::fmin(T(1), std::fmax(T(-1), a))) }; }
constexpr auto	safe_acos (T a)

template<typename T , typename U > requires std::is_scalar_v<T> && std::is_scalar_v<U>
constexpr auto	eq (T a, U b)

template<typename T , typename U > requires std::is_scalar_v<T> && std::is_scalar_v<U>
constexpr auto	neq (T a, U b)


	BBM_ARRAY_FUNC (exp)
	Math Functions on iterable containers.

	BBM_ARRAY_FUNC (log)

	BBM_ARRAY_FUNC (sin)

	BBM_ARRAY_FUNC (asin)

	BBM_ARRAY_FUNC (cos)

	BBM_ARRAY_FUNC (acos)

	BBM_ARRAY_FUNC (tan)

	BBM_ARRAY_FUNC (atan)

	BBM_ARRAY_FUNC (sinh)

	BBM_ARRAY_FUNC (asinh)

	BBM_ARRAY_FUNC (cosh)

	BBM_ARRAY_FUNC (acosh)

	BBM_ARRAY_FUNC (tanh)

	BBM_ARRAY_FUNC (atanh)

	BBM_ARRAY_FUNC (ceil)

	BBM_ARRAY_FUNC (floor)

	BBM_ARRAY_FUNC (round)

	BBM_ARRAY_FUNC (abs)

	BBM_ARRAY_FUNC (sign)

	BBM_ARRAY_FUNC (sqrt)

	BBM_ARRAY_FUNC (cbrt)

	BBM_ARRAY_FUNC (rcp)

	BBM_ARRAY_FUNC (rsqrt)

	BBM_ARRAY_FUNC (safe_sqrt)

	BBM_ARRAY_FUNC (safe_asin)

	BBM_ARRAY_FUNC (safe_acos)

	BBM_ARRAY_FUNC (erf)

	BBM_ARRAY_FUNC (erfc)

	BBM_ARRAY_FUNC (erfinv)

	BBM_ARRAY_FUNC (tgamma)

	BBM_ARRAY_FUNC (lgamma)

	BBM_ARRAY_FUNC (eq)

	BBM_ARRAY_FUNC (neq)

	BBM_ARRAY_FUNC (atan2)

	BBM_ARRAY_FUNC (max)

	BBM_ARRAY_FUNC (min)

	BBM_ARRAY_FUNC (fmod)

	BBM_ARRAY_FUNC (copysign)

	BBM_ARRAY_FUNC (pow)

	BBM_ARRAY_FUNC (lerp)

	BBM_ARRAY_FUNC (clamp)

	BBM_ARRAY_FUNC (isnan)

	BBM_ARRAY_FUNC (isinf)

	BBM_ARRAY_FUNC (isfinite)

template<typename T > requires is_array_v<T> && requires(const T& t) {{ cos(t) }; { sin(t) }; }
vec2d< T >	cossin (const T &a)

Variables
static constexpr seed_t	default_seed = PCG32_DEFAULT_STATE

template<typename T >
static constexpr bool	is_LLVMArray_v = detail::is_LLVMArray<std::decay_t<T>>::value
	true if the type is an LLVMArray

template<typename T >
constexpr bool	is_DiffArray_v = backbone::detail::is_diff<std::decay_t<T>>::value
	true if DiffArray type

static constexpr seed_t	default_seed = PCG32_DEFAULT_STATE

template<typename T >
static constexpr size_t	packet_size = detail::packet_size<T>::size
	get packet size from type

template<typename T >
static constexpr size_t	array_size = detail::array_size< std::decay_t<T> >::value
	array_size type traits

static constexpr seed_t	default_seed = std::mt19937_64::default_seed
	Default seed.

template<typename T >
using	mask_t = drjit::mask_t< T >
	Direct mapping to DrJIT traits.

template<typename T >
using	value_t = typename backbone::detail::value< std::decay_t< T > >::type
	Value trait.

template<typename T >
using	scalar_t = drjit::scalar_t< std::decay_t< T > >
	Scalar trait.

template<typename T , typename R >
using	replace_scalar_t = drjit::replace_scalar_t< std::decay_t< T >, R >
	Replace_scalar trait.

template<typename T >
constexpr bool	is_mask_v = drjit::is_mask_v<T>

Differentiability traits
template<typename T >
using	remove_diff_t = typename detail::remove_diff< std::decay_t< T > >::type
	Strip autodiff from type T.

template<typename T >
constexpr bool	is_diff_v = std::disjunction< backbone::detail::is_diff<std::decay_t<T>>, backbone::detail::is_diff<drjit::value_t<std::decay_t<T>>>>::value
	true if type supports autodiff

Packet traits
template<typename T >
using	remove_packet_t = typename detail::remove_packet< std::decay_t< T > >::type
	Strip packet type from T.

template<typename T >
constexpr bool	is_packet_v = std::disjunction< detail::is_packet<std::decay_t<T>>, detail::is_packet<value_t<std::decay_t<T>>> >::value
	true is the type is a packet

Index traits
template<typename T >
using	index_t = typename detail::index_impl< std::decay_t< T > >::type
	Return the index type.

template<typename T >
using	index_mask_t = typename detail::index_impl< std::decay_t< T > >::mask
	Return the mask of an index of a type.

template<typename T >
constexpr bool	is_index_v = detail::is_index<std::decay_t<T>>::value
	true if the type is an index type

is_array type traits
template<typename T >
using	is_array = detail::is_array< std::decay_t< T > >

template<typename T >
constexpr bool	is_array_v = is_array<T>::value

type traits
template<typename T >
using	is_complex = detail::is_complex_impl< std::decay_t< T > >

template<typename T >
constexpr bool	is_complex_v = is_complex<T>::value

Detailed Description

Random number generator; built on top of Drjit.

Random number generator; built on top of STL.

Complex numbers; built on top of array.

Random number generator; built on top of Enoki.

\filename random.h

\filename complex.h

\filename random.h

Class Documentation

◆ backbone::add_diff_t

struct backbone::add_diff_t

template<typename T>
struct backbone::add_diff_t< T >

◆ backbone::add_packet_t

struct backbone::add_packet_t

template<typename T>
struct backbone::add_packet_t< T >

◆ backbone::array

struct backbone::array

template<typename T, size_t N>
struct backbone::array< T, N >

Typedef Documentation

◆ add_diff_t

using add_diff_t = typename detail::add_diff<std::decay_t<T> >::type

Add autodiff to type T.

◆ add_packet_t

using add_packet_t = typename detail::add_packet<std::decay_t<T> >::type

Add packet to type T.

◆ color

using color = array<T, 3>

◆ complex

using complex = enoki::Complex<T>

Alias drjit::Complex.

Alias enoki::Complex.

◆ index_mask_t

using index_mask_t = bool

Return the mask of an index of a type.

◆ index_t

using index_t = size_t

Return the index type.

◆ is_array

using is_array = detail::is_array<std::decay_t<T> >

◆ is_complex

using is_complex = detail::is_complex_impl<std::decay_t<T> >

◆ mask_t

using mask_t = replace_scalar_t<T, bool>

Direct mapping to DrJIT traits.

◆ remove_diff_t

using remove_diff_t = std::decay_t<T>

Strip autodiff from type T.

◆ remove_packet_t

using remove_packet_t = std::decay_t<T>

Strip packet type from T.

Strip packet from type T.

◆ replace_scalar_t

using replace_scalar_t = typename detail::replace_scalar<std::decay_t<T>, R>::type

Replace_scalar trait.

◆ result_t

using result_t = typename detail::result_impl<T...>::type

determine the mathematical result type; reverts to first argument if '+' is not defined on T...

◆ scalar_t

using scalar_t = typename detail::scalar_impl<std::decay_t<T> >::type

Scalar trait.

◆ seed_t

typedef std::uint_fast64_t seed_t

seed type

◆ value_t

using value_t = typename detail::value_impl<std::decay_t<T> >::type

Value trait.

◆ vec2d

using vec2d = array<T, 2>

◆ vec3d

using vec3d = array<T, 3>

Function Documentation

◆ all() [1/2]

bool all ( const array< bool, N > & t )

inline

\Name Mask operations on arrays

◆ all() [2/2]

bool all ( const T & t )

inline

◆ any() [1/2]

bool any ( const array< bool, N > & t )

inline

◆ any() [2/2]

bool any ( const T & t )

inline

◆ atan2() [1/2]

auto atan2	(	drjit::Complex< T >	a,
		drjit::Complex< U >	b
	)

delete

delete atan2 to avoid static_error

◆ atan2() [2/2]

constexpr auto atan2	(	T	a,
		U	b
	)

inlineconstexpr

◆ backward_gradient()

void backward_gradient ( T & )

◆ BBM_ARRAY_FUNC() [1/44]

BBM_ARRAY_FUNC ( abs )

◆ BBM_ARRAY_FUNC() [2/44]

BBM_ARRAY_FUNC ( acos )

◆ BBM_ARRAY_FUNC() [3/44]

BBM_ARRAY_FUNC ( acosh )

◆ BBM_ARRAY_FUNC() [4/44]

BBM_ARRAY_FUNC ( asin )

◆ BBM_ARRAY_FUNC() [5/44]

BBM_ARRAY_FUNC ( asinh )

◆ BBM_ARRAY_FUNC() [6/44]

BBM_ARRAY_FUNC ( atan )

◆ BBM_ARRAY_FUNC() [7/44]

BBM_ARRAY_FUNC ( atan2 )

◆ BBM_ARRAY_FUNC() [8/44]

BBM_ARRAY_FUNC ( atanh )

◆ BBM_ARRAY_FUNC() [9/44]

BBM_ARRAY_FUNC ( cbrt )

◆ BBM_ARRAY_FUNC() [10/44]

BBM_ARRAY_FUNC ( ceil )

◆ BBM_ARRAY_FUNC() [11/44]

BBM_ARRAY_FUNC ( clamp )

◆ BBM_ARRAY_FUNC() [12/44]

BBM_ARRAY_FUNC ( copysign )

◆ BBM_ARRAY_FUNC() [13/44]

BBM_ARRAY_FUNC ( cos )

◆ BBM_ARRAY_FUNC() [14/44]

BBM_ARRAY_FUNC ( cosh )

◆ BBM_ARRAY_FUNC() [15/44]

BBM_ARRAY_FUNC ( eq )

◆ BBM_ARRAY_FUNC() [16/44]

BBM_ARRAY_FUNC ( erf )

◆ BBM_ARRAY_FUNC() [17/44]

BBM_ARRAY_FUNC ( erfc )

◆ BBM_ARRAY_FUNC() [18/44]

BBM_ARRAY_FUNC ( erfinv )

◆ BBM_ARRAY_FUNC() [19/44]

BBM_ARRAY_FUNC ( exp )

Math Functions on iterable containers.

◆ BBM_ARRAY_FUNC() [20/44]

BBM_ARRAY_FUNC ( floor )

◆ BBM_ARRAY_FUNC() [21/44]

BBM_ARRAY_FUNC ( fmod )

◆ BBM_ARRAY_FUNC() [22/44]

BBM_ARRAY_FUNC ( isfinite )

◆ BBM_ARRAY_FUNC() [23/44]

BBM_ARRAY_FUNC ( isinf )

◆ BBM_ARRAY_FUNC() [24/44]

BBM_ARRAY_FUNC ( isnan )

◆ BBM_ARRAY_FUNC() [25/44]

BBM_ARRAY_FUNC ( lerp )

◆ BBM_ARRAY_FUNC() [26/44]

BBM_ARRAY_FUNC ( lgamma )

◆ BBM_ARRAY_FUNC() [27/44]

BBM_ARRAY_FUNC ( log )

◆ BBM_ARRAY_FUNC() [28/44]

BBM_ARRAY_FUNC ( max )

◆ BBM_ARRAY_FUNC() [29/44]

BBM_ARRAY_FUNC ( min )

◆ BBM_ARRAY_FUNC() [30/44]

BBM_ARRAY_FUNC ( neq )

◆ BBM_ARRAY_FUNC() [31/44]

BBM_ARRAY_FUNC ( pow )

◆ BBM_ARRAY_FUNC() [32/44]

BBM_ARRAY_FUNC ( rcp )

◆ BBM_ARRAY_FUNC() [33/44]

BBM_ARRAY_FUNC ( round )

◆ BBM_ARRAY_FUNC() [34/44]

BBM_ARRAY_FUNC ( rsqrt )

◆ BBM_ARRAY_FUNC() [35/44]

BBM_ARRAY_FUNC ( safe_acos )

◆ BBM_ARRAY_FUNC() [36/44]

BBM_ARRAY_FUNC ( safe_asin )

◆ BBM_ARRAY_FUNC() [37/44]

BBM_ARRAY_FUNC ( safe_sqrt )

◆ BBM_ARRAY_FUNC() [38/44]

BBM_ARRAY_FUNC ( sign )

◆ BBM_ARRAY_FUNC() [39/44]

BBM_ARRAY_FUNC ( sin )

◆ BBM_ARRAY_FUNC() [40/44]

BBM_ARRAY_FUNC ( sinh )

◆ BBM_ARRAY_FUNC() [41/44]

BBM_ARRAY_FUNC ( sqrt )

◆ BBM_ARRAY_FUNC() [42/44]

BBM_ARRAY_FUNC ( tan )

◆ BBM_ARRAY_FUNC() [43/44]

BBM_ARRAY_FUNC ( tanh )

◆ BBM_ARRAY_FUNC() [44/44]

BBM_ARRAY_FUNC ( tgamma )

◆ BBM_DECL_COMPLEX_OP() [1/16]

BBM_DECL_COMPLEX_OP ( acos )

◆ BBM_DECL_COMPLEX_OP() [2/16]

BBM_DECL_COMPLEX_OP ( acosh )

◆ BBM_DECL_COMPLEX_OP() [3/16]

BBM_DECL_COMPLEX_OP ( asin )

◆ BBM_DECL_COMPLEX_OP() [4/16]

BBM_DECL_COMPLEX_OP ( asinh )

◆ BBM_DECL_COMPLEX_OP() [5/16]

BBM_DECL_COMPLEX_OP ( atan )

◆ BBM_DECL_COMPLEX_OP() [6/16]

BBM_DECL_COMPLEX_OP ( atanh )

◆ BBM_DECL_COMPLEX_OP() [7/16]

BBM_DECL_COMPLEX_OP ( cos )

◆ BBM_DECL_COMPLEX_OP() [8/16]

BBM_DECL_COMPLEX_OP ( cosh )

◆ BBM_DECL_COMPLEX_OP() [9/16]

BBM_DECL_COMPLEX_OP ( exp )

◆ BBM_DECL_COMPLEX_OP() [10/16]

BBM_DECL_COMPLEX_OP ( log )

◆ BBM_DECL_COMPLEX_OP() [11/16]

BBM_DECL_COMPLEX_OP ( pow )

◆ BBM_DECL_COMPLEX_OP() [12/16]

BBM_DECL_COMPLEX_OP ( sin )

◆ BBM_DECL_COMPLEX_OP() [13/16]

BBM_DECL_COMPLEX_OP ( sinh )

◆ BBM_DECL_COMPLEX_OP() [14/16]

BBM_DECL_COMPLEX_OP ( sqrt )

◆ BBM_DECL_COMPLEX_OP() [15/16]

BBM_DECL_COMPLEX_OP ( tan )

◆ BBM_DECL_COMPLEX_OP() [16/16]

BBM_DECL_COMPLEX_OP ( tanh )

◆ BBM_ENOKI_MATHOP() [1/44]

BBM_ENOKI_MATHOP ( abs )

◆ BBM_ENOKI_MATHOP() [2/44]

BBM_ENOKI_MATHOP ( acos )

◆ BBM_ENOKI_MATHOP() [3/44]

BBM_ENOKI_MATHOP ( acosh )

◆ BBM_ENOKI_MATHOP() [4/44]

BBM_ENOKI_MATHOP ( asin )

◆ BBM_ENOKI_MATHOP() [5/44]

BBM_ENOKI_MATHOP ( asinh )

◆ BBM_ENOKI_MATHOP() [6/44]

BBM_ENOKI_MATHOP ( atan )

◆ BBM_ENOKI_MATHOP() [7/44]

BBM_ENOKI_MATHOP ( atan2 )

◆ BBM_ENOKI_MATHOP() [8/44]

BBM_ENOKI_MATHOP ( atanh )

◆ BBM_ENOKI_MATHOP() [9/44]

BBM_ENOKI_MATHOP ( cbrt )

◆ BBM_ENOKI_MATHOP() [10/44]

BBM_ENOKI_MATHOP ( ceil )

◆ BBM_ENOKI_MATHOP() [11/44]

BBM_ENOKI_MATHOP ( clamp )

◆ BBM_ENOKI_MATHOP() [12/44]

BBM_ENOKI_MATHOP ( copysign )

◆ BBM_ENOKI_MATHOP() [13/44]

BBM_ENOKI_MATHOP ( cos )

◆ BBM_ENOKI_MATHOP() [14/44]

BBM_ENOKI_MATHOP ( cosh )

◆ BBM_ENOKI_MATHOP() [15/44]

BBM_ENOKI_MATHOP ( eq )

◆ BBM_ENOKI_MATHOP() [16/44]

BBM_ENOKI_MATHOP ( erf )

◆ BBM_ENOKI_MATHOP() [17/44]

BBM_ENOKI_MATHOP ( erfc )

◆ BBM_ENOKI_MATHOP() [18/44]

BBM_ENOKI_MATHOP ( erfinv )

◆ BBM_ENOKI_MATHOP() [19/44]

BBM_ENOKI_MATHOP ( exp )

◆ BBM_ENOKI_MATHOP() [20/44]

BBM_ENOKI_MATHOP ( floor )

◆ BBM_ENOKI_MATHOP() [21/44]

BBM_ENOKI_MATHOP ( fmod )

◆ BBM_ENOKI_MATHOP() [22/44]

BBM_ENOKI_MATHOP ( isfinite )

◆ BBM_ENOKI_MATHOP() [23/44]

BBM_ENOKI_MATHOP ( isinf )

◆ BBM_ENOKI_MATHOP() [24/44]

BBM_ENOKI_MATHOP ( isnan )

◆ BBM_ENOKI_MATHOP() [25/44]

BBM_ENOKI_MATHOP ( lerp )

◆ BBM_ENOKI_MATHOP() [26/44]

BBM_ENOKI_MATHOP ( lgamma )

◆ BBM_ENOKI_MATHOP() [27/44]

BBM_ENOKI_MATHOP ( log )

◆ BBM_ENOKI_MATHOP() [28/44]

BBM_ENOKI_MATHOP ( max )

◆ BBM_ENOKI_MATHOP() [29/44]

BBM_ENOKI_MATHOP ( min )

◆ BBM_ENOKI_MATHOP() [30/44]

BBM_ENOKI_MATHOP ( neq )

◆ BBM_ENOKI_MATHOP() [31/44]

BBM_ENOKI_MATHOP ( pow )

◆ BBM_ENOKI_MATHOP() [32/44]

BBM_ENOKI_MATHOP ( rcp )

◆ BBM_ENOKI_MATHOP() [33/44]

BBM_ENOKI_MATHOP ( round )

◆ BBM_ENOKI_MATHOP() [34/44]

BBM_ENOKI_MATHOP ( rsqrt )

◆ BBM_ENOKI_MATHOP() [35/44]

BBM_ENOKI_MATHOP ( safe_acos )

◆ BBM_ENOKI_MATHOP() [36/44]

BBM_ENOKI_MATHOP ( safe_asin )

◆ BBM_ENOKI_MATHOP() [37/44]

BBM_ENOKI_MATHOP ( safe_sqrt )

◆ BBM_ENOKI_MATHOP() [38/44]

BBM_ENOKI_MATHOP ( sign )

◆ BBM_ENOKI_MATHOP() [39/44]

BBM_ENOKI_MATHOP ( sin )

◆ BBM_ENOKI_MATHOP() [40/44]

BBM_ENOKI_MATHOP ( sinh )

◆ BBM_ENOKI_MATHOP() [41/44]

BBM_ENOKI_MATHOP ( sqrt )

◆ BBM_ENOKI_MATHOP() [42/44]

BBM_ENOKI_MATHOP ( tan )

◆ BBM_ENOKI_MATHOP() [43/44]

BBM_ENOKI_MATHOP ( tanh )

◆ BBM_ENOKI_MATHOP() [44/44]

BBM_ENOKI_MATHOP ( tgamma )

◆ binary_search() [1/2]

constexpr size_t binary_search	(	C &&	container,
		PRED &&	predicate,
		bool	mask = `true`
	)

inlineconstexpr

binary_search

◆ binary_search() [2/2]

constexpr index_t< bbm::iterable_value_t< C > > binary_search	(	C &&	container,
		PRED &&	predicate,
		const index_mask_t< bbm::iterable_value_t< C > > &	mask = `true`
	)

inlineconstexpr

binary search

◆ cast() [1/2]

NEWTYPE cast ( OLDTYPE && val )

cast

◆ cast() [2/2]

constexpr NEWTYPE cast ( OLDTYPE && val )

inlineconstexpr

cast

◆ clamp()

constexpr auto clamp	(	const T &	a,
		const L &	l,
		const U &	u
	)

inlineconstexpr

◆ conj()

constexpr complex< T > conj ( complex< T > z )

inlineconstexpr

◆ cossin() [1/4]

constexpr vec2d< complex< T > > cossin ( complex< T > z )

inlineconstexpr

cossin method

◆ cossin() [2/4]

vec2d< T > cossin ( const T & a )

cossin

Parameters

a = angle

Returns: the cos and sin in a vec2d

Parameters

a = angle

Returns: the cos and sin in a vec2d

◆ cossin() [3/4]

vec2d< T > cossin ( const T & a )

inline

◆ cossin() [4/4]

constexpr vec2d< T > cossin ( T a )

inlineconstexpr

◆ count() [1/2]

size_t count ( const array< bool, N > & t )

inline

◆ count() [2/2]

size_t count ( const T & t )

inline

◆ detach_gradient()

remove_diff_t< T > & detach_gradient ( T & )

◆ dot() [1/3]

auto dot	(	const array< T, N > &	a,
		const array< U, N > &	b
	)

inline

◆ dot() [2/3]

auto dot	(	const T &	a,
		const T &	b
	)

inline

Direct mapping to DrJIT methods if not a scalar

◆ dot() [3/3]

T dot	(	const T &	a,
		const T &	b
	)

inline

◆ eq()

constexpr auto eq	(	T	a,
		U	b
	)

inlineconstexpr

◆ erfc()

T erfc ( const T & t )

inline

erfc

TODO: make more robust

◆ erfinv()

constexpr auto erfinv ( T a )

inlineconstexpr

◆ fmod()

constexpr auto fmod	(	T	a,
		U	b
	)

inlineconstexpr