SecreC 2 language  2.8.0 (2023.09)
Language and standard library reference
Functions
shared3p.sc File Reference

Functions

template<domain D :shared3p , dim N>
D int8 sign (D int8[[N]] x)
 
template<domain D :shared3p , dim N>
D int16 sign (D int16[[N]] x)
 
template<domain D :shared3p , dim N>
D int32 sign (D int32[[N]] x)
 
template<domain D :shared3p , dim N>
D int sign (D int[[N]] x)
 
template<domain D :shared3p , dim N>
D uint8 abs (D int8[[N]] x)
 
template<domain D :shared3p , dim N>
D uint16 abs (D int16[[N]] x)
 
template<domain D :shared3p , dim N>
D uint32 abs (D int32[[N]] x)
 
template<domain D :shared3p , dim N>
D uint abs (D int[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 abs (D float32[[N]] value)
 
template<domain D :shared3p , dim N>
D float64 abs (D float64[[N]] value)
 
template<domain D :shared3p , dim N>
D fix32 abs (D fix32[[N]] value)
 
template<domain D :shared3p , dim N>
D fix64 abs (D fix64[[N]] value)
 
template<domain D :shared3p >
D uint sum (D bool[[1]] vec)
 
template<domain D :shared3p >
D uint8 sum (D uint8[[1]] vec)
 
template<domain D :shared3p >
D uint16 sum (D uint16[[1]] vec)
 
template<domain D :shared3p >
D uint32 sum (D uint32[[1]] vec)
 
template<domain D :shared3p >
D uint sum (D uint[[1]] vec)
 
template<domain D :shared3p >
D int8 sum (D int8[[1]] vec)
 
template<domain D :shared3p >
D int16 sum (D int16[[1]] vec)
 
template<domain D :shared3p >
D int32 sum (D int32[[1]] vec)
 
template<domain D :shared3p >
D int sum (D int[[1]] vec)
 
template<domain D :shared3p >
D float32 sum (D float32[[1]] vec)
 
template<domain D :shared3p >
D float64 sum (D float64[[1]] vec)
 
template<domain D :shared3p >
D fix32 sum (D fix32[[1]] vec)
 
template<domain D :shared3p >
D fix64 sum (D fix64[[1]] vec)
 
template<domain D :shared3p >
D uint sum (D bool[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint8 sum (D uint8[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint16 sum (D uint16[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint32 sum (D uint32[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint sum (D uint[[1]] vec, uint k)
 
template<domain D :shared3p >
D int8 sum (D int8[[1]] vec, uint k)
 
template<domain D :shared3p >
D int16 sum (D int16[[1]] vec, uint k)
 
template<domain D :shared3p >
D int32 sum (D int32[[1]] vec, uint k)
 
template<domain D :shared3p >
D int sum (D int[[1]] vec, uint k)
 
template<domain D :shared3p >
D float32 sum (D float32[[1]] vec, uint k)
 
template<domain D :shared3p >
D float64 sum (D float64[[1]] vec, uint k)
 
template<domain D :shared3p >
D fix32 sum (D fix32[[1]] vec, uint k)
 
template<domain D :shared3p >
D fix64 sum (D fix64[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint8 prefixSum (D uint8[[1]] vec)
 
template<domain D :shared3p >
D uint16 prefixSum (D uint16[[1]] vec)
 
template<domain D :shared3p >
D uint32 prefixSum (D uint32[[1]] vec)
 
template<domain D :shared3p >
D uint64 prefixSum (D uint64[[1]] vec)
 
template<domain D :shared3p >
D int8 prefixSum (D int8[[1]] vec)
 
template<domain D :shared3p >
D int16 prefixSum (D int16[[1]] vec)
 
template<domain D :shared3p >
D int32 prefixSum (D int32[[1]] vec)
 
template<domain D :shared3p >
D int64 prefixSum (D int64[[1]] vec)
 
template<domain D :shared3p >
D uint8 invPrefixSum (D uint8[[1]] vec)
 
template<domain D :shared3p >
D uint16 invPrefixSum (D uint16[[1]] vec)
 
template<domain D :shared3p >
D uint32 invPrefixSum (D uint32[[1]] vec)
 
template<domain D :shared3p >
D uint64 invPrefixSum (D uint64[[1]] vec)
 
template<domain D :shared3p >
D int8 invPrefixSum (D int8[[1]] vec)
 
template<domain D :shared3p >
D int16 invPrefixSum (D int16[[1]] vec)
 
template<domain D :shared3p >
D int32 invPrefixSum (D int32[[1]] vec)
 
template<domain D :shared3p >
D int64 invPrefixSum (D int64[[1]] vec)
 
template<domain D :shared3p , type T>
D T product (D T scalar)
 
template<domain D :shared3p >
D uint8 product (D uint8[[1]] vec)
 
template<domain D :shared3p >
D uint16 product (D uint16[[1]] vec)
 
template<domain D :shared3p >
D uint32 product (D uint32[[1]] vec)
 
template<domain D :shared3p >
D uint product (D uint[[1]] vec)
 
template<domain D :shared3p >
D int8 product (D int8[[1]] vec)
 
template<domain D :shared3p >
D int16 product (D int16[[1]] vec)
 
template<domain D :shared3p >
D int32 product (D int32[[1]] vec)
 
template<domain D :shared3p >
D int product (D int[[1]] vec)
 
template<domain D :shared3p >
D uint8 product (D uint8[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint16 product (D uint16[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint32 product (D uint32[[1]] vec, uint k)
 
template<domain D :shared3p >
D uint product (D uint[[1]] vec, uint k)
 
template<domain D :shared3p >
D int8 product (D int8[[1]] vec, uint k)
 
template<domain D :shared3p >
D int16 product (D int16[[1]] vec, uint k)
 
template<domain D :shared3p >
D int32 product (D int32[[1]] vec, uint k)
 
template<domain D :shared3p >
D int product (D int[[1]] vec, uint k)
 
template<domain D :shared3p >
D bool any (D bool b)
 
template<domain D :shared3p >
D bool any (D bool[[1]] vec)
 
template<domain D :shared3p >
D bool any (D bool[[1]] vec, uint k)
 
template<domain D :shared3p , dim N>
D bool any (D bool[[N]] arr)
 
template<domain D :shared3p >
D bool all (D bool b)
 
template<domain D :shared3p >
D bool all (D bool[[1]] vec)
 
template<domain D :shared3p >
D bool all (D bool[[1]] vec, uint k)
 
template<domain D :shared3p , dim N>
D bool all (D bool[[N]] arr)
 
template<domain D :shared3p >
D uint truePrefixLength (D bool[[1]] arr)
 
template<domain D :shared3p , dim N>
D float32 inv (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 inv (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D fix32 inv (D fix32[[N]] x)
 
template<domain D :shared3p , dim N>
D fix64 inv (D fix64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 sqrt (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 sqrt (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D fix32 sqrt (D fix32[[N]] x)
 
template<domain D :shared3p , dim N>
D fix64 sqrt (D fix64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 sin (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 sin (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 ln (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 ln (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D fix32 ln (D fix32[[N]] x)
 
template<domain D :shared3p , dim N>
D fix64 ln (D fix64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 log (D float32[[N]] x, D float32[[N]] b)
 
template<domain D :shared3p , dim N>
D float64 log (D float64[[N]] x, D float64[[N]] b)
 
template<domain D :shared3p , dim N>
D fix32 log (D fix32[[N]] x, D fix32[[N]] b)
 
template<domain D :shared3p , dim N>
D fix64 log (D fix64[[N]] x, D fix64[[N]] b)
 
template<domain D :shared3p , dim N>
D float32 log10 (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 log10 (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 exp (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 exp (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D fix32 exp (D fix32[[N]] x)
 
template<domain D :shared3p , dim N>
D fix64 exp (D fix64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 erf (D float32[[N]] x)
 
template<domain D :shared3p , dim N>
D float64 erf (D float64[[N]] x)
 
template<domain D :shared3p , dim N>
D float32 pow (D float32[[N]] a, D float32[[N]] b)
 
template<domain D :shared3p , dim N>
D float64 pow (D float64[[N]] a, D float64[[N]] b)
 
template<domain D :shared3p >
D bool isNegligible (D float32 a)
 
template<domain D :shared3p >
D bool isNegligible (D float64 a)
 
template<domain D :shared3p >
D bool isNegligible (D float32[[1]] a)
 
template<domain D :shared3p >
D bool isNegligible (D float64[[1]] a)
 
template<domain D :shared3p , type T>
D T min (D T x)
 
template<domain D :shared3p >
D uint8 min (D uint8[[1]] x)
 
template<domain D :shared3p >
D uint16 min (D uint16[[1]] x)
 
template<domain D :shared3p >
D uint32 min (D uint32[[1]] x)
 
template<domain D :shared3p >
D uint min (D uint[[1]] x)
 
template<domain D :shared3p >
D int8 min (D int8[[1]] x)
 
template<domain D :shared3p >
D int16 min (D int16[[1]] x)
 
template<domain D :shared3p >
D int32 min (D int32[[1]] x)
 
template<domain D :shared3p >
D int min (D int[[1]] x)
 
template<domain D :shared3p >
D float32 min (D float32[[1]] x)
 
template<domain D :shared3p >
D float64 min (D float64[[1]] x)
 
template<domain D :shared3p >
D xor_uint8 min (D xor_uint8[[1]] x)
 
template<domain D :shared3p >
D xor_uint16 min (D xor_uint16[[1]] x)
 
template<domain D :shared3p >
D xor_uint32 min (D xor_uint32[[1]] x)
 
template<domain D :shared3p >
D xor_uint64 min (D xor_uint64[[1]] x)
 
template<domain D :shared3p >
D uint8 min (D uint8[[1]] x, uint k)
 
template<domain D :shared3p >
D uint16 min (D uint16[[1]] x, uint k)
 
template<domain D :shared3p >
D uint32 min (D uint32[[1]] x, uint k)
 
template<domain D :shared3p >
D uint min (D uint[[1]] x, uint k)
 
template<domain D :shared3p >
D int8 min (D int8[[1]] x, uint k)
 
template<domain D :shared3p >
D int16 min (D int16[[1]] x, uint k)
 
template<domain D :shared3p >
D int32 min (D int32[[1]] x, uint k)
 
template<domain D :shared3p >
D int min (D int[[1]] x, uint k)
 
template<domain D :shared3p >
D uint8 min (D uint8 x, D uint8 y)
 
template<domain D :shared3p >
D uint16 min (D uint16 x, D uint16 y)
 
template<domain D :shared3p >
D uint32 min (D uint32 x, D uint32 y)
 
template<domain D :shared3p >
D uint min (D uint x, D uint y)
 
template<domain D :shared3p >
D int8 min (D int8 x, D int8 y)
 
template<domain D :shared3p >
D int16 min (D int16 x, D int16 y)
 
template<domain D :shared3p >
D int32 min (D int32 x, D int32 y)
 
template<domain D :shared3p >
D int min (D int x, D int y)
 
template<domain D :shared3p >
D float32 min (D float32 x, D float32 y)
 
template<domain D :shared3p >
D float64 min (D float64 x, D float64 y)
 
template<domain D :shared3p >
D uint8 min (D uint8[[1]] x, D uint8[[1]] y)
 
template<domain D :shared3p >
D uint16 min (D uint16[[1]] x, D uint16[[1]] y)
 
template<domain D :shared3p >
D uint32 min (D uint32[[1]] x, D uint32[[1]] y)
 
template<domain D :shared3p >
D uint min (D uint[[1]] x, D uint[[1]] y)
 
template<domain D :shared3p >
D int8 min (D int8[[1]] x, D int8[[1]] y)
 
template<domain D :shared3p >
D int16 min (D int16[[1]] x, D int16[[1]] y)
 
template<domain D :shared3p >
D int32 min (D int32[[1]] x, D int32[[1]] y)
 
template<domain D :shared3p >
D int min (D int[[1]] x, D int[[1]] y)
 
template<domain D :shared3p >
D float32 min (D float32[[1]] x, D float32[[1]] y)
 
template<domain D :shared3p >
D float64 min (D float64[[1]] x, D float64[[1]] y)
 
template<domain D :shared3p , dim N>
D uint8 min (D uint8[[N]] x, D uint8[[N]] y)
 
template<domain D :shared3p , dim N>
D uint16 min (D uint16[[N]] x, D uint16[[N]] y)
 
template<domain D :shared3p , dim N>
D uint32 min (D uint32[[N]] x, D uint32[[N]] y)
 
template<domain D :shared3p , dim N>
D uint min (D uint[[N]] x, D uint[[N]] y)
 
template<domain D :shared3p , dim N>
D int8 min (D int8[[N]] x, D int8[[N]] y)
 
template<domain D :shared3p , dim N>
D int16 min (D int16[[N]] x, D int16[[N]] y)
 
template<domain D :shared3p , dim N>
D int32 min (D int32[[N]] x, D int32[[N]] y)
 
template<domain D :shared3p , dim N>
D int min (D int[[N]] x, D int[[N]] y)
 
template<domain D :shared3p , dim N>
D float32 min (D float32[[N]] x, D float32[[N]] y)
 
template<domain D :shared3p , dim N>
D float64 min (D float64[[N]] x, D float64[[N]] y)
 
template<domain D :shared3p >
D xor_uint8 min (D xor_uint8 x, D xor_uint8 y)
 
template<domain D :shared3p >
D xor_uint16 min (D xor_uint16 x, D xor_uint16 y)
 
template<domain D :shared3p >
D xor_uint32 min (D xor_uint32 x, D xor_uint32 y)
 
template<domain D :shared3p >
D xor_uint64 min (D xor_uint64 x, D xor_uint64 y)
 
template<domain D :shared3p >
D xor_uint8 min (D xor_uint8[[1]] x, D xor_uint8[[1]] y)
 
template<domain D :shared3p >
D xor_uint16 min (D xor_uint16[[1]] x, D xor_uint16[[1]] y)
 
template<domain D :shared3p >
D xor_uint32 min (D xor_uint32[[1]] x, D xor_uint32[[1]] y)
 
template<domain D :shared3p >
D xor_uint64 min (D xor_uint64[[1]] x, D xor_uint64[[1]] y)
 
template<domain D :shared3p , dim N>
D xor_uint8 min (D xor_uint8[[N]] x, D xor_uint8[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint16 min (D xor_uint16[[N]] x, D xor_uint16[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint32 min (D xor_uint32[[N]] x, D xor_uint32[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint64 min (D xor_uint64[[N]] x, D xor_uint64[[N]] y)
 
template<domain D :shared3p , type T>
D T max (D T x)
 
template<domain D :shared3p >
D uint8 max (D uint8[[1]] x)
 
template<domain D :shared3p >
D uint16 max (D uint16[[1]] x)
 
template<domain D :shared3p >
D uint32 max (D uint32[[1]] x)
 
template<domain D :shared3p >
D uint max (D uint[[1]] x)
 
template<domain D :shared3p >
D int8 max (D int8[[1]] x)
 
template<domain D :shared3p >
D int16 max (D int16[[1]] x)
 
template<domain D :shared3p >
D int32 max (D int32[[1]] x)
 
template<domain D :shared3p >
D int max (D int[[1]] x)
 
template<domain D :shared3p >
D float32 max (D float32[[1]] x)
 
template<domain D :shared3p >
D float64 max (D float64[[1]] x)
 
template<domain D :shared3p >
D xor_uint8 max (D xor_uint8[[1]] x)
 
template<domain D :shared3p >
D xor_uint16 max (D xor_uint16[[1]] x)
 
template<domain D :shared3p >
D xor_uint32 max (D xor_uint32[[1]] x)
 
template<domain D :shared3p >
D xor_uint64 max (D xor_uint64[[1]] x)
 
template<domain D :shared3p >
D uint8 max (D uint8[[1]] x, uint k)
 
template<domain D :shared3p >
D uint16 max (D uint16[[1]] x, uint k)
 
template<domain D :shared3p >
D uint32 max (D uint32[[1]] x, uint k)
 
template<domain D :shared3p >
D uint max (D uint[[1]] x, uint k)
 
template<domain D :shared3p >
D int8 max (D int8[[1]] x, uint k)
 
template<domain D :shared3p >
D int16 max (D int16[[1]] x, uint k)
 
template<domain D :shared3p >
D int32 max (D int32[[1]] x, uint k)
 
template<domain D :shared3p >
D int max (D int[[1]] x, uint k)
 
template<domain D :shared3p >
D uint8 max (D uint8 x, D uint8 y)
 
template<domain D :shared3p >
D uint16 max (D uint16 x, D uint16 y)
 
template<domain D :shared3p >
D uint32 max (D uint32 x, D uint32 y)
 
template<domain D :shared3p >
D uint max (D uint x, D uint y)
 
template<domain D :shared3p >
D int8 max (D int8 x, D int8 y)
 
template<domain D :shared3p >
D int16 max (D int16 x, D int16 y)
 
template<domain D :shared3p >
D int32 max (D int32 x, D int32 y)
 
template<domain D :shared3p >
D int max (D int x, D int y)
 
template<domain D :shared3p >
D float32 max (D float32 x, D float32 y)
 
template<domain D :shared3p >
D float64 max (D float64 x, D float64 y)
 
template<domain D :shared3p >
D uint8 max (D uint8[[1]] x, D uint8[[1]] y)
 
template<domain D :shared3p >
D uint16 max (D uint16[[1]] x, D uint16[[1]] y)
 
template<domain D :shared3p >
D uint32 max (D uint32[[1]] x, D uint32[[1]] y)
 
template<domain D :shared3p >
D uint max (D uint[[1]] x, D uint[[1]] y)
 
template<domain D :shared3p >
D int8 max (D int8[[1]] x, D int8[[1]] y)
 
template<domain D :shared3p >
D int16 max (D int16[[1]] x, D int16[[1]] y)
 
template<domain D :shared3p >
D int32 max (D int32[[1]] x, D int32[[1]] y)
 
template<domain D :shared3p >
D int max (D int[[1]] x, D int[[1]] y)
 
template<domain D :shared3p >
D float32 max (D float32[[1]] x, D float32[[1]] y)
 
template<domain D :shared3p >
D float64 max (D float64[[1]] x, D float64[[1]] y)
 
template<domain D :shared3p , dim N>
D uint8 max (D uint8[[N]] x, D uint8[[N]] y)
 
template<domain D :shared3p , dim N>
D uint16 max (D uint16[[N]] x, D uint16[[N]] y)
 
template<domain D :shared3p , dim N>
D uint32 max (D uint32[[N]] x, D uint32[[N]] y)
 
template<domain D :shared3p , dim N>
D uint max (D uint[[N]] x, D uint[[N]] y)
 
template<domain D :shared3p , dim N>
D int8 max (D int8[[N]] x, D int8[[N]] y)
 
template<domain D :shared3p , dim N>
D int16 max (D int16[[N]] x, D int16[[N]] y)
 
template<domain D :shared3p , dim N>
D int32 max (D int32[[N]] x, D int32[[N]] y)
 
template<domain D :shared3p , dim N>
D int max (D int[[N]] x, D int[[N]] y)
 
template<domain D :shared3p , dim N>
D float32 max (D float32[[N]] x, D float32[[N]] y)
 
template<domain D :shared3p , dim N>
D float64 max (D float64[[N]] x, D float64[[N]] y)
 
template<domain D :shared3p >
D xor_uint8 max (D xor_uint8 x, D xor_uint8 y)
 
template<domain D :shared3p >
D xor_uint16 max (D xor_uint16 x, D xor_uint16 y)
 
template<domain D :shared3p >
D xor_uint32 max (D xor_uint32 x, D xor_uint32 y)
 
template<domain D :shared3p >
D xor_uint64 max (D xor_uint64 x, D xor_uint64 y)
 
template<domain D :shared3p >
D xor_uint8 max (D xor_uint8[[1]] x, D xor_uint8[[1]] y)
 
template<domain D :shared3p >
D xor_uint16 max (D xor_uint16[[1]] x, D xor_uint16[[1]] y)
 
template<domain D :shared3p >
D xor_uint32 max (D xor_uint32[[1]] x, D xor_uint32[[1]] y)
 
template<domain D :shared3p >
D xor_uint64 max (D xor_uint64[[1]] x, D xor_uint64[[1]] y)
 
template<domain D :shared3p , dim N>
D xor_uint8 max (D xor_uint8[[N]] x, D xor_uint8[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint16 max (D xor_uint16[[N]] x, D xor_uint16[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint32 max (D xor_uint32[[N]] x, D xor_uint32[[N]] y)
 
template<domain D :shared3p , dim N>
D xor_uint64 max (D xor_uint64[[N]] x, D xor_uint64[[N]] y)
 
template<domain D :shared3p >
D float32 floor (D float32 value)
 
template<domain D :shared3p >
D float64 floor (D float64 value)
 
template<domain D :shared3p >
D float32 floor (D float32[[1]] arr)
 
template<domain D :shared3p >
D float64 floor (D float64[[1]] arr)
 
template<domain D :shared3p >
D float32 ceiling (D float32 value)
 
template<domain D :shared3p >
D float64 ceiling (D float64 value)
 
template<domain D :shared3p >
D float32 ceiling (D float32[[1]] arr)
 
template<domain D :shared3p >
D float64 ceiling (D float64[[1]] arr)
 
template<domain D :shared3p , type T>
D T argument (string name)
 
template<domain D :shared3p , type T, dim N>
void publish (string name, D T[[N]] val)
 
template<domain D :shared3p , dim N>
D bool bit_extract (D xor_uint8[[N]] input)
 
template<domain D :shared3p , dim N>
D bool bit_extract (D xor_uint16[[N]] input)
 
template<domain D :shared3p , dim N>
D bool bit_extract (D xor_uint32[[N]] input)
 
template<domain D :shared3p , dim N>
D bool bit_extract (D xor_uint64[[N]] input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D uint8 input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D int8 input)
 
template<domain D :shared3p >
D uint8 reshare (D xor_uint8 input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D uint8[[1]] input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D int8[[1]] input)
 
template<domain D :shared3p >
D uint8 reshare (D xor_uint8[[1]] input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D uint8[[2]] input)
 
template<domain D :shared3p >
D xor_uint8 reshare (D int8[[2]] input)
 
template<domain D :shared3p >
D uint8 reshare (D xor_uint8[[2]] input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D uint16 input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D int16 input)
 
template<domain D :shared3p >
D uint16 reshare (D xor_uint16 input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D uint16[[1]] input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D int16[[1]] input)
 
template<domain D :shared3p >
D uint16 reshare (D xor_uint16[[1]] input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D uint16[[2]] input)
 
template<domain D :shared3p >
D xor_uint16 reshare (D int16[[2]] input)
 
template<domain D :shared3p >
D uint16 reshare (D xor_uint16[[2]] input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D uint32 input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D int32 input)
 
template<domain D :shared3p >
D uint32 reshare (D xor_uint32 input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D uint32[[1]] input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D int32[[1]] input)
 
template<domain D :shared3p >
D uint32 reshare (D xor_uint32[[1]] input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D uint32[[2]] input)
 
template<domain D :shared3p >
D xor_uint32 reshare (D int32[[2]] input)
 
template<domain D :shared3p >
D uint32 reshare (D xor_uint32[[2]] input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D uint64 input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D int64 input)
 
template<domain D :shared3p >
D uint64 reshare (D xor_uint64 input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D uint64[[1]] input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D int64[[1]] input)
 
template<domain D :shared3p >
D uint64 reshare (D xor_uint64[[1]] input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D uint64[[2]] input)
 
template<domain D :shared3p >
D xor_uint64 reshare (D int64[[2]] input)
 
template<domain D :shared3p >
D uint64 reshare (D xor_uint64[[2]] input)
 
template<domain D :shared3p , dim N>
D xor_uint8 choose (D bool cond, D xor_uint8[[N]] first, D xor_uint8[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint16 choose (D bool cond, D xor_uint16[[N]] first, D xor_uint16[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint32 choose (D bool cond, D xor_uint32[[N]] first, D xor_uint32[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint64 choose (D bool cond, D xor_uint64[[N]] first, D xor_uint64[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint8 choose (D bool[[N]] cond, D xor_uint8[[N]] first, D xor_uint8[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint16 choose (D bool[[N]] cond, D xor_uint16[[N]] first, D xor_uint16[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint32 choose (D bool[[N]] cond, D xor_uint32[[N]] first, D xor_uint32[[N]] second)
 
template<domain D :shared3p , dim N>
D xor_uint64 choose (D bool[[N]] cond, D xor_uint64[[N]] first, D xor_uint64[[N]] second)
 
template<domain D :shared3p >
D float64 logGamma (D float64[[1]] x)