Halide 19.0.0
Halide compiler and libraries
|
Defines various operator overloads and utility functions that make it more pleasant to work with Halide expressions. More...
Go to the source code of this file.
Classes | |
struct | Halide::Internal::BufferBuilder |
A builder to help create Exprs representing halide_buffer_t structs (e.g. More... | |
struct | Halide::Internal::is_printable_arg< T > |
struct | Halide::Internal::all_are_printable_args< Args > |
Namespaces | |
namespace | Halide |
This file defines the class FunctionDAG, which is our representation of a Halide pipeline, and contains methods to using Halide's bounds tools to query properties of it. | |
namespace | Halide::Internal |
Functions | |
bool | Halide::Internal::is_const (const Expr &e) |
Is the expression either an IntImm, a FloatImm, a StringImm, or a Cast of the same, or a Ramp or Broadcast of the same. | |
bool | Halide::Internal::is_const (const Expr &e, int64_t v) |
Is the expression an IntImm, FloatImm of a particular value, or a Cast, or Broadcast of the same. | |
const int64_t * | Halide::Internal::as_const_int (const Expr &e) |
If an expression is an IntImm or a Broadcast of an IntImm, return a pointer to its value. | |
const uint64_t * | Halide::Internal::as_const_uint (const Expr &e) |
If an expression is a UIntImm or a Broadcast of a UIntImm, return a pointer to its value. | |
const double * | Halide::Internal::as_const_float (const Expr &e) |
If an expression is a FloatImm or a Broadcast of a FloatImm, return a pointer to its value. | |
bool | Halide::Internal::is_const_power_of_two_integer (const Expr &e, int *bits) |
Is the expression a constant integer power of two. | |
bool | Halide::Internal::is_positive_const (const Expr &e) |
Is the expression a const (as defined by is_const), and also strictly greater than zero (in all lanes, if a vector expression) | |
bool | Halide::Internal::is_negative_const (const Expr &e) |
Is the expression a const (as defined by is_const), and also strictly less than zero (in all lanes, if a vector expression) | |
bool | Halide::Internal::is_undef (const Expr &e) |
Is the expression an undef. | |
bool | Halide::Internal::is_const_zero (const Expr &e) |
Is the expression a const (as defined by is_const), and also equal to zero (in all lanes, if a vector expression) | |
bool | Halide::Internal::is_const_one (const Expr &e) |
Is the expression a const (as defined by is_const), and also equal to one (in all lanes, if a vector expression) | |
bool | Halide::Internal::is_no_op (const Stmt &s) |
Is the statement a no-op (which we represent as either an undefined Stmt, or as an Evaluate node of a constant) | |
bool | Halide::Internal::is_pure (const Expr &e) |
Does the expression 1) Take on the same value no matter where it appears in a Stmt, and 2) Evaluating it has no side-effects. | |
Expr | Halide::Internal::make_const (Type t, int64_t val) |
Construct an immediate of the given type from any numeric C++ type. | |
Expr | Halide::Internal::make_const (Type t, uint64_t val) |
Expr | Halide::Internal::make_const (Type t, double val) |
Expr | Halide::Internal::make_const (Type t, int32_t val) |
Expr | Halide::Internal::make_const (Type t, uint32_t val) |
Expr | Halide::Internal::make_const (Type t, int16_t val) |
Expr | Halide::Internal::make_const (Type t, uint16_t val) |
Expr | Halide::Internal::make_const (Type t, int8_t val) |
Expr | Halide::Internal::make_const (Type t, uint8_t val) |
Expr | Halide::Internal::make_const (Type t, bool val) |
Expr | Halide::Internal::make_const (Type t, float val) |
Expr | Halide::Internal::make_const (Type t, float16_t val) |
Expr | Halide::Internal::make_signed_integer_overflow (Type type) |
Construct a unique signed_integer_overflow Expr. | |
bool | Halide::Internal::is_signed_integer_overflow (const Expr &expr) |
Check if an expression is a signed_integer_overflow. | |
void | Halide::Internal::check_representable (Type t, int64_t val) |
Check if a constant value can be correctly represented as the given type. | |
Expr | Halide::Internal::make_bool (bool val, int lanes=1) |
Construct a boolean constant from a C++ boolean value. | |
Expr | Halide::Internal::make_zero (Type t) |
Construct the representation of zero in the given type. | |
Expr | Halide::Internal::make_one (Type t) |
Construct the representation of one in the given type. | |
Expr | Halide::Internal::make_two (Type t) |
Construct the representation of two in the given type. | |
Expr | Halide::Internal::const_true (int lanes=1) |
Construct the constant boolean true. | |
Expr | Halide::Internal::const_false (int lanes=1) |
Construct the constant boolean false. | |
Expr | Halide::Internal::lossless_cast (Type t, Expr e, std::map< Expr, ConstantInterval, ExprCompare > *cache=nullptr) |
Attempt to cast an expression to a smaller type while provably not losing information. | |
Expr | Halide::Internal::lossless_negate (const Expr &x) |
Attempt to negate x without introducing new IR and without overflow. | |
void | Halide::Internal::match_types (Expr &a, Expr &b) |
Coerce the two expressions to have the same type, using C-style casting rules. | |
void | Halide::Internal::match_types_bitwise (Expr &a, Expr &b, const char *op_name) |
Asserts that both expressions are integer types and are either both signed or both unsigned. | |
Expr | Halide::Internal::halide_log (const Expr &a) |
Halide's vectorizable transcendentals. | |
Expr | Halide::Internal::halide_exp (const Expr &a) |
Expr | Halide::Internal::halide_erf (const Expr &a) |
Expr | Halide::Internal::raise_to_integer_power (Expr a, int64_t b) |
Raise an expression to an integer power by repeatedly multiplying it by itself. | |
void | Halide::Internal::split_into_ands (const Expr &cond, std::vector< Expr > &result) |
Split a boolean condition into vector of ANDs. | |
Expr | Halide::Internal::strided_ramp_base (const Expr &e, int stride=1) |
If e is a ramp expression with stride, default 1, return the base, otherwise undefined. | |
template<typename T > | |
T | Halide::Internal::mod_imp (T a, T b) |
Implementations of division and mod that are specific to Halide. | |
template<typename T > | |
T | Halide::Internal::div_imp (T a, T b) |
template<> | |
float | Halide::Internal::mod_imp< float > (float a, float b) |
template<> | |
double | Halide::Internal::mod_imp< double > (double a, double b) |
template<> | |
float | Halide::Internal::div_imp< float > (float a, float b) |
template<> | |
double | Halide::Internal::div_imp< double > (double a, double b) |
Expr | Halide::Internal::remove_likelies (const Expr &e) |
Return an Expr that is identical to the input Expr, but with all calls to likely() and likely_if_innermost() removed. | |
Stmt | Halide::Internal::remove_likelies (const Stmt &s) |
Return a Stmt that is identical to the input Stmt, but with all calls to likely() and likely_if_innermost() removed. | |
Expr | Halide::Internal::remove_promises (const Expr &e) |
Return an Expr that is identical to the input Expr, but with all calls to promise_clamped() and unsafe_promise_clamped() removed. | |
Stmt | Halide::Internal::remove_promises (const Stmt &s) |
Return a Stmt that is identical to the input Stmt, but with all calls to promise_clamped() and unsafe_promise_clamped() removed. | |
Expr | Halide::Internal::unwrap_tags (const Expr &e) |
If the expression is a tag helper call, remove it and return the tagged expression. | |
HALIDE_NO_USER_CODE_INLINE void | Halide::Internal::collect_print_args (std::vector< Expr > &args) |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE void | Halide::Internal::collect_print_args (std::vector< Expr > &args, const char *arg, Args &&...more_args) |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE void | Halide::Internal::collect_print_args (std::vector< Expr > &args, Expr arg, Args &&...more_args) |
Expr | Halide::Internal::requirement_failed_error (Expr condition, const std::vector< Expr > &args) |
Expr | Halide::Internal::memoize_tag_helper (Expr result, const std::vector< Expr > &cache_key_values) |
void | Halide::Internal::reset_random_counters () |
Reset the counters used for random-number seeds in random_float/int/uint. | |
template<typename T > | |
Expr | Halide::cast (Expr a) |
Cast an expression to the halide type corresponding to the C++ type T. | |
Expr | Halide::cast (Type t, Expr a) |
Cast an expression to a new type. | |
Expr | Halide::operator+ (Expr a, Expr b) |
Return the sum of two expressions, doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator+ (Expr a, int b) |
Add an expression and a constant integer. | |
Expr | Halide::operator+ (int a, Expr b) |
Add a constant integer and an expression. | |
Expr & | Halide::operator+= (Expr &a, Expr b) |
Modify the first expression to be the sum of two expressions, without changing its type. | |
Expr | Halide::operator- (Expr a, Expr b) |
Return the difference of two expressions, doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator- (Expr a, int b) |
Subtracts a constant integer from an expression. | |
Expr | Halide::operator- (int a, Expr b) |
Subtracts an expression from a constant integer. | |
Expr | Halide::operator- (Expr a) |
Return the negative of the argument. | |
Expr & | Halide::operator-= (Expr &a, Expr b) |
Modify the first expression to be the difference of two expressions, without changing its type. | |
Expr | Halide::operator* (Expr a, Expr b) |
Return the product of two expressions, doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator* (Expr a, int b) |
Multiply an expression and a constant integer. | |
Expr | Halide::operator* (int a, Expr b) |
Multiply a constant integer and an expression. | |
Expr & | Halide::operator*= (Expr &a, Expr b) |
Modify the first expression to be the product of two expressions, without changing its type. | |
Expr | Halide::operator/ (Expr a, Expr b) |
Return the ratio of two expressions, doing any necessary type coercion using Internal::match_types. | |
Expr & | Halide::operator/= (Expr &a, Expr b) |
Modify the first expression to be the ratio of two expressions, without changing its type. | |
Expr | Halide::operator/ (Expr a, int b) |
Divides an expression by a constant integer. | |
Expr | Halide::operator/ (int a, Expr b) |
Divides a constant integer by an expression. | |
Expr | Halide::operator% (Expr a, Expr b) |
Return the first argument reduced modulo the second, doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator% (Expr a, int b) |
Mods an expression by a constant integer. | |
Expr | Halide::operator% (int a, Expr b) |
Mods a constant integer by an expression. | |
Expr | Halide::operator> (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is greater than the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator> (Expr a, int b) |
Return a boolean expression that tests whether an expression is greater than a constant integer. | |
Expr | Halide::operator> (int a, Expr b) |
Return a boolean expression that tests whether a constant integer is greater than an expression. | |
Expr | Halide::operator< (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is less than the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator< (Expr a, int b) |
Return a boolean expression that tests whether an expression is less than a constant integer. | |
Expr | Halide::operator< (int a, Expr b) |
Return a boolean expression that tests whether a constant integer is less than an expression. | |
Expr | Halide::operator<= (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is less than or equal to the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator<= (Expr a, int b) |
Return a boolean expression that tests whether an expression is less than or equal to a constant integer. | |
Expr | Halide::operator<= (int a, Expr b) |
Return a boolean expression that tests whether a constant integer is less than or equal to an expression. | |
Expr | Halide::operator>= (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is greater than or equal to the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator>= (const Expr &a, int b) |
Return a boolean expression that tests whether an expression is greater than or equal to a constant integer. | |
Expr | Halide::operator>= (int a, const Expr &b) |
Return a boolean expression that tests whether a constant integer is greater than or equal to an expression. | |
Expr | Halide::operator== (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is equal to the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator== (Expr a, int b) |
Return a boolean expression that tests whether an expression is equal to a constant integer. | |
Expr | Halide::operator== (int a, Expr b) |
Return a boolean expression that tests whether a constant integer is equal to an expression. | |
Expr | Halide::operator!= (Expr a, Expr b) |
Return a boolean expression that tests whether the first argument is not equal to the second, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::operator!= (Expr a, int b) |
Return a boolean expression that tests whether an expression is not equal to a constant integer. | |
Expr | Halide::operator!= (int a, Expr b) |
Return a boolean expression that tests whether a constant integer is not equal to an expression. | |
Expr | Halide::operator&& (Expr a, Expr b) |
Returns the logical and of the two arguments. | |
Expr | Halide::operator&& (Expr a, bool b) |
Logical and of an Expr and a bool. | |
Expr | Halide::operator&& (bool a, Expr b) |
Expr | Halide::operator|| (Expr a, Expr b) |
Returns the logical or of the two arguments. | |
Expr | Halide::operator|| (Expr a, bool b) |
Logical or of an Expr and a bool. | |
Expr | Halide::operator|| (bool a, Expr b) |
Expr | Halide::operator! (Expr a) |
Returns the logical not the argument. | |
Expr | Halide::max (Expr a, Expr b) |
Returns an expression representing the greater of the two arguments, after doing any necessary type coercion using Internal::match_types. | |
Expr | Halide::max (Expr a, int b) |
Returns an expression representing the greater of an expression and a constant integer. | |
Expr | Halide::max (int a, Expr b) |
Returns an expression representing the greater of a constant integer and an expression. | |
Expr | Halide::max (float a, Expr b) |
Expr | Halide::max (Expr a, float b) |
template<typename A , typename B , typename C , typename... Rest, typename std::enable_if< Halide::Internal::all_are_convertible< Expr, Rest... >::value >::type * = nullptr> | |
Expr | Halide::max (A &&a, B &&b, C &&c, Rest &&...rest) |
Returns an expression representing the greater of an expressions vector, after doing any necessary type coersion using Internal::match_types. | |
Expr | Halide::min (Expr a, Expr b) |
Expr | Halide::min (Expr a, int b) |
Returns an expression representing the lesser of an expression and a constant integer. | |
Expr | Halide::min (int a, Expr b) |
Returns an expression representing the lesser of a constant integer and an expression. | |
Expr | Halide::min (float a, Expr b) |
Expr | Halide::min (Expr a, float b) |
template<typename A , typename B , typename C , typename... Rest, typename std::enable_if< Halide::Internal::all_are_convertible< Expr, Rest... >::value >::type * = nullptr> | |
Expr | Halide::min (A &&a, B &&b, C &&c, Rest &&...rest) |
Returns an expression representing the lesser of an expressions vector, after doing any necessary type coersion using Internal::match_types. | |
Expr | Halide::operator+ (Expr a, float b) |
Operators on floats treats those floats as Exprs. | |
Expr | Halide::operator+ (float a, Expr b) |
Expr | Halide::operator- (Expr a, float b) |
Expr | Halide::operator- (float a, Expr b) |
Expr | Halide::operator* (Expr a, float b) |
Expr | Halide::operator* (float a, Expr b) |
Expr | Halide::operator/ (Expr a, float b) |
Expr | Halide::operator/ (float a, Expr b) |
Expr | Halide::operator% (Expr a, float b) |
Expr | Halide::operator% (float a, Expr b) |
Expr | Halide::operator> (Expr a, float b) |
Expr | Halide::operator> (float a, Expr b) |
Expr | Halide::operator< (Expr a, float b) |
Expr | Halide::operator< (float a, Expr b) |
Expr | Halide::operator>= (Expr a, float b) |
Expr | Halide::operator>= (float a, Expr b) |
Expr | Halide::operator<= (Expr a, float b) |
Expr | Halide::operator<= (float a, Expr b) |
Expr | Halide::operator== (Expr a, float b) |
Expr | Halide::operator== (float a, Expr b) |
Expr | Halide::operator!= (Expr a, float b) |
Expr | Halide::operator!= (float a, Expr b) |
Expr | Halide::clamp (Expr a, const Expr &min_val, const Expr &max_val) |
Clamps an expression to lie within the given bounds. | |
Expr | Halide::abs (Expr a) |
Returns the absolute value of a signed integer or floating-point expression. | |
Expr | Halide::absd (Expr a, Expr b) |
Return the absolute difference between two values. | |
Expr | Halide::select (Expr condition, Expr true_value, Expr false_value) |
Returns an expression similar to the ternary operator in C, except that it always evaluates all arguments. | |
template<typename... Args, typename std::enable_if< Halide::Internal::all_are_convertible< Expr, Args... >::value >::type * = nullptr> | |
Expr | Halide::select (Expr c0, Expr v0, Expr c1, Expr v1, Args &&...args) |
A multi-way variant of select similar to a switch statement in C, which can accept multiple conditions and values in pairs. | |
Tuple | Halide::select (const Tuple &condition, const Tuple &true_value, const Tuple &false_value) |
Equivalent of ternary select(), but taking/returning tuples. | |
Tuple | Halide::select (const Expr &condition, const Tuple &true_value, const Tuple &false_value) |
template<typename... Args> | |
Tuple | Halide::select (const Tuple &c0, const Tuple &v0, const Tuple &c1, const Tuple &v1, Args &&...args) |
Equivalent of multiway select(), but taking/returning tuples. | |
template<typename... Args> | |
Tuple | Halide::select (const Expr &c0, const Tuple &v0, const Expr &c1, const Tuple &v1, Args &&...args) |
Expr | Halide::select (const Expr &condition, const FuncRef &true_value, const FuncRef &false_value) |
select applied to FuncRefs (e.g. | |
template<typename... Args> | |
Expr | Halide::select (const Expr &c0, const FuncRef &v0, const Expr &c1, const FuncRef &v1, Args &&...args) |
Expr | Halide::mux (const Expr &id, const std::initializer_list< Expr > &values) |
Oftentimes we want to pack a list of expressions with the same type into a channel dimension, e.g., img(x, y, c) = select(c == 0, 100, // Red c == 1, 50, // Green 25); // Blue This is tedious when the list is long. | |
Expr | Halide::mux (const Expr &id, const std::vector< Expr > &values) |
Expr | Halide::mux (const Expr &id, const Tuple &values) |
Expr | Halide::mux (const Expr &id, const std::initializer_list< FuncRef > &values) |
Tuple | Halide::mux (const Expr &id, const std::initializer_list< Tuple > &values) |
Tuple | Halide::mux (const Expr &id, const std::vector< Tuple > &values) |
Expr | Halide::sin (Expr x) |
Return the sine of a floating-point expression. | |
Expr | Halide::asin (Expr x) |
Return the arcsine of a floating-point expression. | |
Expr | Halide::cos (Expr x) |
Return the cosine of a floating-point expression. | |
Expr | Halide::acos (Expr x) |
Return the arccosine of a floating-point expression. | |
Expr | Halide::tan (Expr x) |
Return the tangent of a floating-point expression. | |
Expr | Halide::atan (Expr x) |
Return the arctangent of a floating-point expression. | |
Expr | Halide::atan2 (Expr y, Expr x) |
Return the angle of a floating-point gradient. | |
Expr | Halide::sinh (Expr x) |
Return the hyperbolic sine of a floating-point expression. | |
Expr | Halide::asinh (Expr x) |
Return the hyperbolic arcsinhe of a floating-point expression. | |
Expr | Halide::cosh (Expr x) |
Return the hyperbolic cosine of a floating-point expression. | |
Expr | Halide::acosh (Expr x) |
Return the hyperbolic arccosine of a floating-point expression. | |
Expr | Halide::tanh (Expr x) |
Return the hyperbolic tangent of a floating-point expression. | |
Expr | Halide::atanh (Expr x) |
Return the hyperbolic arctangent of a floating-point expression. | |
Expr | Halide::sqrt (Expr x) |
Return the square root of a floating-point expression. | |
Expr | Halide::hypot (const Expr &x, const Expr &y) |
Return the square root of the sum of the squares of two floating-point expressions. | |
Expr | Halide::exp (Expr x) |
Return the exponential of a floating-point expression. | |
Expr | Halide::log (Expr x) |
Return the logarithm of a floating-point expression. | |
Expr | Halide::pow (Expr x, Expr y) |
Return one floating point expression raised to the power of another. | |
Expr | Halide::erf (const Expr &x) |
Evaluate the error function erf. | |
Expr | Halide::fast_sin (const Expr &x) |
Fast vectorizable approximation to some trigonometric functions for Float(32). | |
Expr | Halide::fast_cos (const Expr &x) |
Expr | Halide::fast_log (const Expr &x) |
Fast approximate cleanly vectorizable log for Float(32). | |
Expr | Halide::fast_exp (const Expr &x) |
Fast approximate cleanly vectorizable exp for Float(32). | |
Expr | Halide::fast_pow (Expr x, Expr y) |
Fast approximate cleanly vectorizable pow for Float(32). | |
Expr | Halide::fast_inverse (Expr x) |
Fast approximate inverse for Float(32). | |
Expr | Halide::fast_inverse_sqrt (Expr x) |
Fast approximate inverse square root for Float(32). | |
Expr | Halide::floor (Expr x) |
Return the greatest whole number less than or equal to a floating-point expression. | |
Expr | Halide::ceil (Expr x) |
Return the least whole number greater than or equal to a floating-point expression. | |
Expr | Halide::round (Expr x) |
Return the whole number closest to a floating-point expression. | |
Expr | Halide::trunc (Expr x) |
Return the integer part of a floating-point expression. | |
Expr | Halide::is_nan (Expr x) |
Returns true if the argument is a Not a Number (NaN). | |
Expr | Halide::is_inf (Expr x) |
Returns true if the argument is Inf or -Inf. | |
Expr | Halide::is_finite (Expr x) |
Returns true if the argument is a finite value (ie, neither NaN nor Inf). | |
Expr | Halide::fract (const Expr &x) |
Return the fractional part of a floating-point expression. | |
Expr | Halide::reinterpret (Type t, Expr e) |
Reinterpret the bits of one value as another type. | |
template<typename T > | |
Expr | Halide::reinterpret (Expr e) |
Expr | Halide::operator& (Expr x, Expr y) |
Return the bitwise and of two expressions (which need not have the same type). | |
Expr | Halide::operator& (Expr x, int y) |
Return the bitwise and of an expression and an integer. | |
Expr | Halide::operator& (int x, Expr y) |
Expr | Halide::operator| (Expr x, Expr y) |
Return the bitwise or of two expressions (which need not have the same type). | |
Expr | Halide::operator| (Expr x, int y) |
Return the bitwise or of an expression and an integer. | |
Expr | Halide::operator| (int x, Expr y) |
Expr | Halide::operator^ (Expr x, Expr y) |
Return the bitwise xor of two expressions (which need not have the same type). | |
Expr | Halide::operator^ (Expr x, int y) |
Return the bitwise xor of an expression and an integer. | |
Expr | Halide::operator^ (int x, Expr y) |
Expr | Halide::operator~ (Expr x) |
Return the bitwise not of an expression. | |
Expr | Halide::operator<< (Expr x, Expr y) |
Shift the bits of an integer value left. | |
Expr | Halide::operator<< (Expr x, int y) |
Expr | Halide::operator>> (Expr x, Expr y) |
Shift the bits of an integer value right. | |
Expr | Halide::operator>> (Expr x, int y) |
Expr | Halide::lerp (Expr zero_val, Expr one_val, Expr weight) |
Linear interpolate between the two values according to a weight. | |
Expr | Halide::popcount (Expr x) |
Count the number of set bits in an expression. | |
Expr | Halide::count_leading_zeros (Expr x) |
Count the number of leading zero bits in an expression. | |
Expr | Halide::count_trailing_zeros (Expr x) |
Count the number of trailing zero bits in an expression. | |
Expr | Halide::div_round_to_zero (Expr x, Expr y) |
Divide two integers, rounding towards zero. | |
Expr | Halide::mod_round_to_zero (Expr x, Expr y) |
Compute the remainder of dividing two integers, when division is rounding toward zero. | |
Expr | Halide::random_float (Expr seed=Expr()) |
Return a random variable representing a uniformly distributed float in the half-open interval [0.0f, 1.0f). | |
Expr | Halide::random_uint (Expr seed=Expr()) |
Return a random variable representing a uniformly distributed unsigned 32-bit integer. | |
Expr | Halide::random_int (Expr seed=Expr()) |
Return a random variable representing a uniformly distributed 32-bit integer. | |
Expr | Halide::print (const std::vector< Expr > &values) |
Create an Expr that prints out its value whenever it is evaluated. | |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE Expr | Halide::print (Expr a, Args &&...args) |
Expr | Halide::print_when (Expr condition, const std::vector< Expr > &values) |
Create an Expr that prints whenever it is evaluated, provided that the condition is true. | |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE Expr | Halide::print_when (Expr condition, Expr a, Args &&...args) |
Expr | Halide::require (Expr condition, const std::vector< Expr > &values) |
Create an Expr that that guarantees a precondition. | |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE Expr | Halide::require (Expr condition, Expr value, Args &&...args) |
Expr | Halide::undef (Type t) |
Return an undef value of the given type. | |
template<typename T > | |
Expr | Halide::undef () |
Expr | Halide::Internal::unreachable (Type t=Int(32)) |
Return an expression that should never be evaluated. | |
template<typename T > | |
Expr | Halide::Internal::unreachable () |
template<typename... Args> | |
HALIDE_NO_USER_CODE_INLINE Expr | Halide::memoize_tag (Expr result, Args &&...args) |
Control the values used in the memoization cache key for memoize. | |
Expr | Halide::likely (Expr e) |
Expressions tagged with this intrinsic are considered to be part of the steady state of some loop with a nasty beginning and end (e.g. | |
Expr | Halide::likely_if_innermost (Expr e) |
Equivalent to likely, but only triggers a loop partitioning if found in an innermost loop. | |
template<typename T > | |
Expr | Halide::saturating_cast (Expr e) |
Cast an expression to the halide type corresponding to the C++ type T. | |
Expr | Halide::saturating_cast (Type t, Expr e) |
Cast an expression to a new type, clamping to the minimum and maximum values of the result type. | |
Expr | Halide::strict_float (Expr e) |
Makes a best effort attempt to preserve IEEE floating-point semantics in evaluating an expression. | |
Expr | Halide::unsafe_promise_clamped (const Expr &value, const Expr &min, const Expr &max) |
Create an Expr that that promises another Expr is clamped but do not generate code to check the assertion or modify the value. | |
Expr | Halide::Internal::promise_clamped (const Expr &value, const Expr &min, const Expr &max) |
FOR INTERNAL USE ONLY. | |
Expr | Halide::scatter (const std::vector< Expr > &args) |
Scatter and gather are used for update definition which must store multiple values to distinct locations at the same time. | |
Expr | Halide::gather (const std::vector< Expr > &args) |
template<typename... Args> | |
Expr | Halide::scatter (const Expr &e, Args &&...args) |
template<typename... Args> | |
Expr | Halide::gather (const Expr &e, Args &&...args) |
Expr | Halide::extract_bits (Type t, const Expr &e, const Expr &lsb) |
Extract a contiguous subsequence of the bits of 'e', starting at the bit index given by 'lsb', where zero is the least-significant bit, returning a value of type 't'. | |
template<typename T > | |
Expr | Halide::extract_bits (const Expr &e, const Expr &lsb) |
Expr | Halide::concat_bits (const std::vector< Expr > &e) |
Given a number of Exprs of the same type, concatenate their bits producing a single Expr of the same type code of the input but with more bits. | |
Expr | Halide::widen_right_add (Expr a, Expr b) |
Below is a collection of intrinsics for fixed-point programming. | |
Expr | Halide::widen_right_mul (Expr a, Expr b) |
Compute a * widen(b). | |
Expr | Halide::widen_right_sub (Expr a, Expr b) |
Compute a - widen(b). | |
Expr | Halide::widening_add (Expr a, Expr b) |
Compute widen(a) + widen(b). | |
Expr | Halide::widening_mul (Expr a, Expr b) |
Compute widen(a) * widen(b). | |
Expr | Halide::widening_sub (Expr a, Expr b) |
Compute widen(a) - widen(b). | |
Expr | Halide::widening_shift_left (Expr a, Expr b) |
Compute widen(a) << b. | |
Expr | Halide::widening_shift_left (Expr a, int b) |
Expr | Halide::widening_shift_right (Expr a, Expr b) |
Compute widen(a) >> b. | |
Expr | Halide::widening_shift_right (Expr a, int b) |
Expr | Halide::rounding_shift_left (Expr a, Expr b) |
Compute saturating_narrow(widening_add(a, (1 >> min(b, 0)) / 2) << b). | |
Expr | Halide::rounding_shift_left (Expr a, int b) |
Expr | Halide::rounding_shift_right (Expr a, Expr b) |
Compute saturating_narrow(widening_add(a, (1 << max(b, 0)) / 2) >> b). | |
Expr | Halide::rounding_shift_right (Expr a, int b) |
Expr | Halide::saturating_add (Expr a, Expr b) |
Compute saturating_narrow(widen(a) + widen(b)) | |
Expr | Halide::saturating_sub (Expr a, Expr b) |
Compute saturating_narrow(widen(a) - widen(b)) | |
Expr | Halide::halving_add (Expr a, Expr b) |
Compute narrow((widen(a) + widen(b)) / 2) | |
Expr | Halide::rounding_halving_add (Expr a, Expr b) |
Compute narrow((widen(a) + widen(b) + 1) / 2) | |
Expr | Halide::halving_sub (Expr a, Expr b) |
Compute narrow((widen(a) - widen(b)) / 2) | |
Expr | Halide::mul_shift_right (Expr a, Expr b, Expr q) |
Compute saturating_narrow(shift_right(widening_mul(a, b), q)) | |
Expr | Halide::mul_shift_right (Expr a, Expr b, int q) |
Expr | Halide::rounding_mul_shift_right (Expr a, Expr b, Expr q) |
Compute saturating_narrow(rounding_shift_right(widening_mul(a, b), q)) | |
Expr | Halide::rounding_mul_shift_right (Expr a, Expr b, int q) |
Expr | Halide::target_arch_is (Target::Arch arch) |
Return a boolean Expr for the corresponding field of the Target being used during lowering; they can be useful in writing library code without having to plumb a Target through call sites, so that you can do things like. | |
Expr | Halide::target_os_is (Target::OS os) |
Expr | Halide::target_has_feature (Target::Feature feat) |
Expr | Halide::target_bits () |
Return the bit width of the Target used during lowering; this can be useful in writing library code without having to plumb a Target through call sites, so that you can do things like. | |
Expr | Halide::target_natural_vector_size (Type t) |
Return the natural vector width for the given Type for the Target being used during lowering; this can be useful in writing library code without having to plumb a Target through call sites, so that you can do things like. | |
template<typename data_t > | |
Expr | Halide::target_natural_vector_size () |
Defines various operator overloads and utility functions that make it more pleasant to work with Halide expressions.
Definition in file IROperator.h.