Halide 19.0.0
Halide compiler and libraries
Loading...
Searching...
No Matches
IROperator.h
Go to the documentation of this file.
1#ifndef HALIDE_IR_OPERATOR_H
2#define HALIDE_IR_OPERATOR_H
3
4/** \file
5 *
6 * Defines various operator overloads and utility functions that make
7 * it more pleasant to work with Halide expressions.
8 */
9
10#include <cmath>
11#include <map>
12
13#include "Expr.h"
14#include "Target.h"
15#include "Tuple.h"
16
17namespace Halide {
18
19namespace Internal {
20/** Is the expression either an IntImm, a FloatImm, a StringImm, or a
21 * Cast of the same, or a Ramp or Broadcast of the same. Doesn't do
22 * any constant folding. */
23bool is_const(const Expr &e);
24
25/** Is the expression an IntImm, FloatImm of a particular value, or a
26 * Cast, or Broadcast of the same. */
27bool is_const(const Expr &e, int64_t v);
28
29/** If an expression is an IntImm or a Broadcast of an IntImm, return
30 * a pointer to its value. Otherwise returns nullptr. */
31const int64_t *as_const_int(const Expr &e);
32
33/** If an expression is a UIntImm or a Broadcast of a UIntImm, return
34 * a pointer to its value. Otherwise returns nullptr. */
35const uint64_t *as_const_uint(const Expr &e);
36
37/** If an expression is a FloatImm or a Broadcast of a FloatImm,
38 * return a pointer to its value. Otherwise returns nullptr. */
39const double *as_const_float(const Expr &e);
40
41/** Is the expression a constant integer power of two. Also returns
42 * log base two of the expression if it is. Only returns true for
43 * integer types. */
44bool is_const_power_of_two_integer(const Expr &e, int *bits);
45
46/** Is the expression a const (as defined by is_const), and also
47 * strictly greater than zero (in all lanes, if a vector expression) */
48bool is_positive_const(const Expr &e);
49
50/** Is the expression a const (as defined by is_const), and also
51 * strictly less than zero (in all lanes, if a vector expression) */
52bool is_negative_const(const Expr &e);
53
54/** Is the expression an undef */
55bool is_undef(const Expr &e);
56
57/** Is the expression a const (as defined by is_const), and also equal
58 * to zero (in all lanes, if a vector expression) */
59bool is_const_zero(const Expr &e);
60
61/** Is the expression a const (as defined by is_const), and also equal
62 * to one (in all lanes, if a vector expression) */
63bool is_const_one(const Expr &e);
64
65/** Is the statement a no-op (which we represent as either an
66 * undefined Stmt, or as an Evaluate node of a constant) */
67bool is_no_op(const Stmt &s);
68
69/** Does the expression
70 * 1) Take on the same value no matter where it appears in a Stmt, and
71 * 2) Evaluating it has no side-effects
72 */
73bool is_pure(const Expr &e);
74
75/** Construct an immediate of the given type from any numeric C++ type. */
76// @{
79Expr make_const(Type t, double val);
80inline Expr make_const(Type t, int32_t val) {
81 return make_const(t, (int64_t)val);
82}
83inline Expr make_const(Type t, uint32_t val) {
84 return make_const(t, (uint64_t)val);
85}
86inline Expr make_const(Type t, int16_t val) {
87 return make_const(t, (int64_t)val);
88}
89inline Expr make_const(Type t, uint16_t val) {
90 return make_const(t, (uint64_t)val);
91}
92inline Expr make_const(Type t, int8_t val) {
93 return make_const(t, (int64_t)val);
94}
95inline Expr make_const(Type t, uint8_t val) {
96 return make_const(t, (uint64_t)val);
97}
98inline Expr make_const(Type t, bool val) {
99 return make_const(t, (uint64_t)val);
100}
101inline Expr make_const(Type t, float val) {
102 return make_const(t, (double)val);
103}
105 return make_const(t, (double)val);
106}
107// @}
108
109/** Construct a unique signed_integer_overflow Expr */
111
112/** Check if an expression is a signed_integer_overflow */
114
115/** Check if a constant value can be correctly represented as the given type. */
117
118/** Construct a boolean constant from a C++ boolean value.
119 * May also be a vector if width is given.
120 * It is not possible to coerce a C++ boolean to Expr because
121 * if we provide such a path then char objects can ambiguously
122 * be converted to Halide Expr or to std::string. The problem
123 * is that C++ does not have a real bool type - it is in fact
124 * close enough to char that C++ does not know how to distinguish them.
125 * make_bool is the explicit coercion. */
126Expr make_bool(bool val, int lanes = 1);
127
128/** Construct the representation of zero in the given type */
130
131/** Construct the representation of one in the given type */
133
134/** Construct the representation of two in the given type */
136
137/** Construct the constant boolean true. May also be a vector of
138 * trues, if a lanes argument is given. */
139Expr const_true(int lanes = 1);
140
141/** Construct the constant boolean false. May also be a vector of
142 * falses, if a lanes argument is given. */
143Expr const_false(int lanes = 1);
144
145/** Attempt to cast an expression to a smaller type while provably not losing
146 * information. If it can't be done, return an undefined Expr.
147 *
148 * Optionally accepts a map that gives the constant bounds of exprs already
149 * analyzed to avoid redoing work across many calls to lossless_cast. It is not
150 * safe to use this optional map in contexts where the same Expr object may
151 * take on a different value. For example:
152 * (let x = 4 in some_expr_object) + (let x = 5 in the_same_expr_object)).
153 * It is safe to use it after uniquify_variable_names has been run. */
154Expr lossless_cast(Type t, Expr e, std::map<Expr, ConstantInterval, ExprCompare> *cache = nullptr);
155
156/** Attempt to negate x without introducing new IR and without overflow.
157 * If it can't be done, return an undefined Expr. */
159
160/** Coerce the two expressions to have the same type, using C-style
161 * casting rules. For the purposes of casting, a boolean type is
162 * UInt(1). We use the following procedure:
163 *
164 * If the types already match, do nothing.
165 *
166 * Then, if one type is a vector and the other is a scalar, the scalar
167 * is broadcast to match the vector width, and we continue.
168 *
169 * Then, if one type is floating-point and the other is not, the
170 * non-float is cast to the floating-point type, and we're done.
171 *
172 * Then, if both types are unsigned ints, the one with fewer bits is
173 * cast to match the one with more bits and we're done.
174 *
175 * Then, if both types are signed ints, the one with fewer bits is
176 * cast to match the one with more bits and we're done.
177 *
178 * Finally, if one type is an unsigned int and the other type is a signed
179 * int, both are cast to a signed int with the greater of the two
180 * bit-widths. For example, matching an Int(8) with a UInt(16) results
181 * in an Int(16).
182 *
183 */
184void match_types(Expr &a, Expr &b);
185
186/** Asserts that both expressions are integer types and are either
187 * both signed or both unsigned. If one argument is scalar and the
188 * other a vector, the scalar is broadcasted to have the same number
189 * of lanes as the vector. If one expression is of narrower type than
190 * the other, it is widened to the bit width of the wider. */
191void match_types_bitwise(Expr &a, Expr &b, const char *op_name);
192
193/** Halide's vectorizable transcendentals. */
194// @{
198// @}
199
200/** Raise an expression to an integer power by repeatedly multiplying
201 * it by itself. */
203
204/** Split a boolean condition into vector of ANDs. If 'cond' is undefined,
205 * return an empty vector. */
206void split_into_ands(const Expr &cond, std::vector<Expr> &result);
207
208/** A builder to help create Exprs representing halide_buffer_t
209 * structs (e.g. foo.buffer) via calls to halide_buffer_init. Fill out
210 * the fields and then call build. The resulting Expr will be a call
211 * to halide_buffer_init with the struct members as arguments. If the
212 * buffer_memory field is undefined, it uses a call to alloca to make
213 * some stack memory for the buffer. If the shape_memory field is
214 * undefined, it similarly uses stack memory for the shape. If the
215 * shape_memory field is null, it uses the dim field already in the
216 * buffer. Other unitialized fields will take on a value of zero in
217 * the constructed buffer. */
227
228/** If e is a ramp expression with stride, default 1, return the base,
229 * otherwise undefined. */
230Expr strided_ramp_base(const Expr &e, int stride = 1);
231
232/** Implementations of division and mod that are specific to Halide.
233 * Use these implementations; do not use native C division or mod to
234 * simplify Halide expressions. Halide division and modulo satisify
235 * the Euclidean definition of division for integers a and b:
236 *
237 /code
238 when b != 0, (a/b)*b + a%b = a
239 0 <= a%b < |b|
240 /endcode
241 *
242 * Additionally, mod by zero returns zero, and div by zero returns
243 * zero. This makes mod and div total functions.
244 */
245// @{
246template<typename T>
247inline T mod_imp(T a, T b) {
248 Type t = type_of<T>();
249 if (!t.is_float() && b == 0) {
250 return 0;
251 } else if (t.is_int()) {
252 int64_t ia = a;
253 int64_t ib = b;
254 int64_t a_neg = ia >> 63;
255 int64_t b_neg = ib >> 63;
256 int64_t b_zero = (ib == 0) ? -1 : 0;
257 ia -= a_neg;
258 int64_t r = ia % (ib | b_zero);
259 r += (a_neg & ((ib ^ b_neg) + ~b_neg));
260 r &= ~b_zero;
261 return r;
262 } else {
263 return a % b;
264 }
265}
266
267template<typename T>
268inline T div_imp(T a, T b) {
269 Type t = type_of<T>();
270 if (!t.is_float() && b == 0) {
271 return (T)0;
272 } else if (t.is_int()) {
273 // Do it as 64-bit
274 int64_t ia = a;
275 int64_t ib = b;
276 int64_t a_neg = ia >> 63;
277 int64_t b_neg = ib >> 63;
278 int64_t b_zero = (ib == 0) ? -1 : 0;
279 ib -= b_zero;
280 ia -= a_neg;
281 int64_t q = ia / ib;
282 q += a_neg & (~b_neg - b_neg);
283 q &= ~b_zero;
284 return (T)q;
285 } else {
286 return a / b;
287 }
288}
289// @}
290
291// Special cases for float, double.
292template<>
293inline float mod_imp<float>(float a, float b) {
294 float f = a - b * (floorf(a / b));
295 // The remainder has the same sign as b.
296 return f;
297}
298template<>
299inline double mod_imp<double>(double a, double b) {
300 double f = a - b * (std::floor(a / b));
301 return f;
302}
303
304template<>
305inline float div_imp<float>(float a, float b) {
306 return a / b;
307}
308template<>
309inline double div_imp<double>(double a, double b) {
310 return a / b;
311}
312
313/** Return an Expr that is identical to the input Expr, but with
314 * all calls to likely() and likely_if_innermost() removed. */
316
317/** Return a Stmt that is identical to the input Stmt, but with
318 * all calls to likely() and likely_if_innermost() removed. */
320
321/** Return an Expr that is identical to the input Expr, but with
322 * all calls to promise_clamped() and unsafe_promise_clamped() removed. */
324
325/** Return a Stmt that is identical to the input Stmt, but with
326 * all calls to promise_clamped() and unsafe_promise_clamped() removed. */
328
329/** If the expression is a tag helper call, remove it and return
330 * the tagged expression. If not, returns the expression. */
332
333template<typename T>
335 static constexpr bool value = std::is_convertible<T, const char *>::value ||
336 std::is_convertible<T, Halide::Expr>::value;
337};
338
339template<typename... Args>
340struct all_are_printable_args : meta_and<is_printable_arg<Args>...> {};
341
342// Secondary args to print can be Exprs or const char *
343inline HALIDE_NO_USER_CODE_INLINE void collect_print_args(std::vector<Expr> &args) {
344}
345
346template<typename... Args>
347inline HALIDE_NO_USER_CODE_INLINE void collect_print_args(std::vector<Expr> &args, const char *arg, Args &&...more_args) {
348 args.emplace_back(std::string(arg));
349 collect_print_args(args, std::forward<Args>(more_args)...);
350}
351
352template<typename... Args>
353inline HALIDE_NO_USER_CODE_INLINE void collect_print_args(std::vector<Expr> &args, Expr arg, Args &&...more_args) {
354 args.push_back(std::move(arg));
355 collect_print_args(args, std::forward<Args>(more_args)...);
356}
357
358Expr requirement_failed_error(Expr condition, const std::vector<Expr> &args);
359
360Expr memoize_tag_helper(Expr result, const std::vector<Expr> &cache_key_values);
361
362/** Reset the counters used for random-number seeds in random_float/int/uint.
363 * (Note that the counters are incremented for each call, even if a seed is passed in.)
364 * This is used for multitarget compilation to ensure that each subtarget gets
365 * the same sequence of random numbers. */
367
368} // namespace Internal
369
370/** Cast an expression to the halide type corresponding to the C++ type T. */
371template<typename T>
372inline Expr cast(Expr a) {
373 return cast(type_of<T>(), std::move(a));
374}
375
376/** Cast an expression to a new type. */
378
379/** Return the sum of two expressions, doing any necessary type
380 * coercion using \ref Internal::match_types */
382
383/** Add an expression and a constant integer. Coerces the type of the
384 * integer to match the type of the expression. Errors if the integer
385 * cannot be represented in the type of the expression. */
386// @{
388
389/** Add a constant integer and an expression. Coerces the type of the
390 * integer to match the type of the expression. Errors if the integer
391 * cannot be represented in the type of the expression. */
393
394/** Modify the first expression to be the sum of two expressions,
395 * without changing its type. This casts the second argument to match
396 * the type of the first. */
398
399/** Return the difference of two expressions, doing any necessary type
400 * coercion using \ref Internal::match_types */
402
403/** Subtracts a constant integer from an expression. Coerces the type of the
404 * integer to match the type of the expression. Errors if the integer
405 * cannot be represented in the type of the expression. */
407
408/** Subtracts an expression from a constant integer. Coerces the type
409 * of the integer to match the type of the expression. Errors if the
410 * integer cannot be represented in the type of the expression. */
412
413/** Return the negative of the argument. Does no type casting, so more
414 * formally: return that number which when added to the original,
415 * yields zero of the same type. For unsigned integers the negative is
416 * still an unsigned integer. E.g. in UInt(8), the negative of 56 is
417 * 200, because 56 + 200 == 0 */
419
420/** Modify the first expression to be the difference of two expressions,
421 * without changing its type. This casts the second argument to match
422 * the type of the first. */
424
425/** Return the product of two expressions, doing any necessary type
426 * coercion using \ref Internal::match_types */
428
429/** Multiply an expression and a constant integer. Coerces the type of the
430 * integer to match the type of the expression. Errors if the integer
431 * cannot be represented in the type of the expression. */
433
434/** Multiply a constant integer and an expression. Coerces the type of
435 * the integer to match the type of the expression. Errors if the
436 * integer cannot be represented in the type of the expression. */
438
439/** Modify the first expression to be the product of two expressions,
440 * without changing its type. This casts the second argument to match
441 * the type of the first. */
443
444/** Return the ratio of two expressions, doing any necessary type
445 * coercion using \ref Internal::match_types. Note that integer
446 * division in Halide is not the same as integer division in C-like
447 * languages in two ways.
448 *
449 * First, signed integer division in Halide rounds according to the
450 * sign of the denominator. This means towards minus infinity for
451 * positive denominators, and towards positive infinity for negative
452 * denominators. This is unlike C, which rounds towards zero. This
453 * decision ensures that upsampling expressions like f(x/2, y/2) don't
454 * have funny discontinuities when x and y cross zero.
455 *
456 * Second, division by zero returns zero instead of faulting. For
457 * types where overflow is defined behavior, division of the largest
458 * negative signed integer by -1 returns the larged negative signed
459 * integer for the type (i.e. it wraps). This ensures that a division
460 * operation can never have a side-effect, which is helpful in Halide
461 * because scheduling directives can expand the domain of computation
462 * of a Func, potentially introducing new zero-division.
463 */
465
466/** Modify the first expression to be the ratio of two expressions,
467 * without changing its type. This casts the second argument to match
468 * the type of the first. Note that signed integer division in Halide
469 * rounds towards minus infinity, unlike C, which rounds towards
470 * zero. */
472
473/** Divides an expression by a constant integer. Coerces the type
474 * of the integer to match the type of the expression. Errors if the
475 * integer cannot be represented in the type of the expression. */
477
478/** Divides a constant integer by an expression. Coerces the type
479 * of the integer to match the type of the expression. Errors if the
480 * integer cannot be represented in the type of the expression. */
482
483/** Return the first argument reduced modulo the second, doing any
484 * necessary type coercion using \ref Internal::match_types. There are
485 * two key differences between C-like languages and Halide for the
486 * modulo operation, which complement the way division works.
487 *
488 * First, the result is never negative, so x % 2 is always zero or
489 * one, unlike in C-like languages. x % -2 is equivalent, and is also
490 * always zero or one. Second, mod by zero evaluates to zero (unlike
491 * in C, where it faults). This makes modulo, like division, a
492 * side-effect-free operation. */
494
495/** Mods an expression by a constant integer. Coerces the type
496 * of the integer to match the type of the expression. Errors if the
497 * integer cannot be represented in the type of the expression. */
499
500/** Mods a constant integer by an expression. Coerces the type
501 * of the integer to match the type of the expression. Errors if the
502 * integer cannot be represented in the type of the expression. */
504
505/** Return a boolean expression that tests whether the first argument
506 * is greater than the second, after doing any necessary type coercion
507 * using \ref Internal::match_types */
509
510/** Return a boolean expression that tests whether an expression is
511 * greater than a constant integer. Coerces the integer to the type of
512 * the expression. Errors if the integer is not representable in that
513 * type. */
515
516/** Return a boolean expression that tests whether a constant integer is
517 * greater than an expression. Coerces the integer to the type of
518 * the expression. Errors if the integer is not representable in that
519 * type. */
521
522/** Return a boolean expression that tests whether the first argument
523 * is less than the second, after doing any necessary type coercion
524 * using \ref Internal::match_types */
526
527/** Return a boolean expression that tests whether an expression is
528 * less than a constant integer. Coerces the integer to the type of
529 * the expression. Errors if the integer is not representable in that
530 * type. */
532
533/** Return a boolean expression that tests whether a constant integer is
534 * less than an expression. Coerces the integer to the type of
535 * the expression. Errors if the integer is not representable in that
536 * type. */
538
539/** Return a boolean expression that tests whether the first argument
540 * is less than or equal to the second, after doing any necessary type
541 * coercion using \ref Internal::match_types */
543
544/** Return a boolean expression that tests whether an expression is
545 * less than or equal to a constant integer. Coerces the integer to
546 * the type of the expression. Errors if the integer is not
547 * representable in that type. */
549
550/** Return a boolean expression that tests whether a constant integer
551 * is less than or equal to an expression. Coerces the integer to the
552 * type of the expression. Errors if the integer is not representable
553 * in that type. */
555
556/** Return a boolean expression that tests whether the first argument
557 * is greater than or equal to the second, after doing any necessary
558 * type coercion using \ref Internal::match_types */
560
561/** Return a boolean expression that tests whether an expression is
562 * greater than or equal to a constant integer. Coerces the integer to
563 * the type of the expression. Errors if the integer is not
564 * representable in that type. */
565Expr operator>=(const Expr &a, int b);
566
567/** Return a boolean expression that tests whether a constant integer
568 * is greater than or equal to an expression. Coerces the integer to the
569 * type of the expression. Errors if the integer is not representable
570 * in that type. */
571Expr operator>=(int a, const Expr &b);
572
573/** Return a boolean expression that tests whether the first argument
574 * is equal to the second, after doing any necessary type coercion
575 * using \ref Internal::match_types */
577
578/** Return a boolean expression that tests whether an expression is
579 * equal to a constant integer. Coerces the integer to the type of the
580 * expression. Errors if the integer is not representable in that
581 * type. */
583
584/** Return a boolean expression that tests whether a constant integer
585 * is equal to an expression. Coerces the integer to the type of the
586 * expression. Errors if the integer is not representable in that
587 * type. */
589
590/** Return a boolean expression that tests whether the first argument
591 * is not equal to the second, after doing any necessary type coercion
592 * using \ref Internal::match_types */
594
595/** Return a boolean expression that tests whether an expression is
596 * not equal to a constant integer. Coerces the integer to the type of
597 * the expression. Errors if the integer is not representable in that
598 * type. */
600
601/** Return a boolean expression that tests whether a constant integer
602 * is not equal to an expression. Coerces the integer to the type of
603 * the expression. Errors if the integer is not representable in that
604 * type. */
606
607/** Returns the logical and of the two arguments */
609
610/** Logical and of an Expr and a bool. Either returns the Expr or an
611 * Expr representing false, depending on the bool. */
612// @{
615// @}
616
617/** Returns the logical or of the two arguments */
619
620/** Logical or of an Expr and a bool. Either returns the Expr or an
621 * Expr representing true, depending on the bool. */
622// @{
625// @}
626
627/** Returns the logical not the argument */
629
630/** Returns an expression representing the greater of the two
631 * arguments, after doing any necessary type coercion using
632 * \ref Internal::match_types. Vectorizes cleanly on most platforms
633 * (with the exception of integer types on x86 without SSE4). */
635
636/** Returns an expression representing the greater of an expression
637 * and a constant integer. The integer is coerced to the type of the
638 * expression. Errors if the integer is not representable as that
639 * type. Vectorizes cleanly on most platforms (with the exception of
640 * integer types on x86 without SSE4). */
641Expr max(Expr a, int b);
642
643/** Returns an expression representing the greater of a constant
644 * integer and an expression. The integer is coerced to the type of
645 * the expression. Errors if the integer is not representable as that
646 * type. Vectorizes cleanly on most platforms (with the exception of
647 * integer types on x86 without SSE4). */
648Expr max(int a, Expr b);
649
650inline Expr max(float a, Expr b) {
651 return max(Expr(a), std::move(b));
652}
653inline Expr max(Expr a, float b) {
654 return max(std::move(a), Expr(b));
655}
656
657/** Returns an expression representing the greater of an expressions
658 * vector, after doing any necessary type coersion using
659 * \ref Internal::match_types. Vectorizes cleanly on most platforms
660 * (with the exception of integer types on x86 without SSE4).
661 * The expressions are folded from right ie. max(.., max(.., ..)).
662 * The arguments can be any mix of types but must all be convertible to Expr. */
663template<typename A, typename B, typename C, typename... Rest,
664 typename std::enable_if<Halide::Internal::all_are_convertible<Expr, Rest...>::value>::type * = nullptr>
665inline Expr max(A &&a, B &&b, C &&c, Rest &&...rest) {
666 return max(std::forward<A>(a), max(std::forward<B>(b), std::forward<C>(c), std::forward<Rest>(rest)...));
667}
668
670
671/** Returns an expression representing the lesser of an expression
672 * and a constant integer. The integer is coerced to the type of the
673 * expression. Errors if the integer is not representable as that
674 * type. Vectorizes cleanly on most platforms (with the exception of
675 * integer types on x86 without SSE4). */
676Expr min(Expr a, int b);
677
678/** Returns an expression representing the lesser of a constant
679 * integer and an expression. The integer is coerced to the type of
680 * the expression. Errors if the integer is not representable as that
681 * type. Vectorizes cleanly on most platforms (with the exception of
682 * integer types on x86 without SSE4). */
683Expr min(int a, Expr b);
684
685inline Expr min(float a, Expr b) {
686 return min(Expr(a), std::move(b));
687}
688inline Expr min(Expr a, float b) {
689 return min(std::move(a), Expr(b));
690}
691
692/** Returns an expression representing the lesser of an expressions
693 * vector, after doing any necessary type coersion using
694 * \ref Internal::match_types. Vectorizes cleanly on most platforms
695 * (with the exception of integer types on x86 without SSE4).
696 * The expressions are folded from right ie. min(.., min(.., ..)).
697 * The arguments can be any mix of types but must all be convertible to Expr. */
698template<typename A, typename B, typename C, typename... Rest,
699 typename std::enable_if<Halide::Internal::all_are_convertible<Expr, Rest...>::value>::type * = nullptr>
700inline Expr min(A &&a, B &&b, C &&c, Rest &&...rest) {
701 return min(std::forward<A>(a), min(std::forward<B>(b), std::forward<C>(c), std::forward<Rest>(rest)...));
702}
703
704/** Operators on floats treats those floats as Exprs. Making these
705 * explicit prevents implicit float->int casts that might otherwise
706 * occur. */
707// @{
708inline Expr operator+(Expr a, float b) {
709 return std::move(a) + Expr(b);
710}
711inline Expr operator+(float a, Expr b) {
712 return Expr(a) + std::move(b);
713}
714inline Expr operator-(Expr a, float b) {
715 return std::move(a) - Expr(b);
716}
717inline Expr operator-(float a, Expr b) {
718 return Expr(a) - std::move(b);
719}
720inline Expr operator*(Expr a, float b) {
721 return std::move(a) * Expr(b);
722}
723inline Expr operator*(float a, Expr b) {
724 return Expr(a) * std::move(b);
725}
726inline Expr operator/(Expr a, float b) {
727 return std::move(a) / Expr(b);
728}
729inline Expr operator/(float a, Expr b) {
730 return Expr(a) / std::move(b);
731}
732inline Expr operator%(Expr a, float b) {
733 return std::move(a) % Expr(b);
734}
735inline Expr operator%(float a, Expr b) {
736 return Expr(a) % std::move(b);
737}
738inline Expr operator>(Expr a, float b) {
739 return std::move(a) > Expr(b);
740}
741inline Expr operator>(float a, Expr b) {
742 return Expr(a) > std::move(b);
743}
744inline Expr operator<(Expr a, float b) {
745 return std::move(a) < Expr(b);
746}
747inline Expr operator<(float a, Expr b) {
748 return Expr(a) < std::move(b);
749}
750inline Expr operator>=(Expr a, float b) {
751 return std::move(a) >= Expr(b);
752}
753inline Expr operator>=(float a, Expr b) {
754 return Expr(a) >= std::move(b);
755}
756inline Expr operator<=(Expr a, float b) {
757 return std::move(a) <= Expr(b);
758}
759inline Expr operator<=(float a, Expr b) {
760 return Expr(a) <= std::move(b);
761}
762inline Expr operator==(Expr a, float b) {
763 return std::move(a) == Expr(b);
764}
765inline Expr operator==(float a, Expr b) {
766 return Expr(a) == std::move(b);
767}
768inline Expr operator!=(Expr a, float b) {
769 return std::move(a) != Expr(b);
770}
771inline Expr operator!=(float a, Expr b) {
772 return Expr(a) != std::move(b);
773}
774// @}
775
776/** Clamps an expression to lie within the given bounds. The bounds
777 * are type-cast to match the expression. Vectorizes as well as min/max. */
778Expr clamp(Expr a, const Expr &min_val, const Expr &max_val);
779
780/** Returns the absolute value of a signed integer or floating-point
781 * expression. Vectorizes cleanly. Unlike in C, abs of a signed
782 * integer returns an unsigned integer of the same bit width. This
783 * means that abs of the most negative integer doesn't overflow. */
785
786/** Return the absolute difference between two values. Vectorizes
787 * cleanly. Returns an unsigned value of the same bit width. There are
788 * various ways to write this yourself, but they contain numerous
789 * gotchas and don't always compile to good code, so use this
790 * instead. */
792
793/** Returns an expression similar to the ternary operator in C, except
794 * that it always evaluates all arguments. If the first argument is
795 * true, then return the second, else return the third. Typically
796 * vectorizes cleanly, but benefits from SSE41 or newer on x86. */
797Expr select(Expr condition, Expr true_value, Expr false_value);
798
799/** A multi-way variant of select similar to a switch statement in C,
800 * which can accept multiple conditions and values in pairs. Evaluates
801 * to the first value for which the condition is true. Returns the
802 * final value if all conditions are false. */
803template<typename... Args,
804 typename std::enable_if<Halide::Internal::all_are_convertible<Expr, Args...>::value>::type * = nullptr>
805inline Expr select(Expr c0, Expr v0, Expr c1, Expr v1, Args &&...args) {
806 return select(std::move(c0), std::move(v0), select(std::move(c1), std::move(v1), std::forward<Args>(args)...));
807}
808
809/** Equivalent of ternary select(), but taking/returning tuples. If the condition is
810 * a Tuple, it must match the size of the true and false Tuples. */
811// @{
812Tuple select(const Tuple &condition, const Tuple &true_value, const Tuple &false_value);
813Tuple select(const Expr &condition, const Tuple &true_value, const Tuple &false_value);
814// @}
815
816/** Equivalent of multiway select(), but taking/returning tuples. If the condition is
817 * a Tuple, it must match the size of the true and false Tuples. */
818// @{
819template<typename... Args>
820inline Tuple select(const Tuple &c0, const Tuple &v0, const Tuple &c1, const Tuple &v1, Args &&...args) {
821 return select(c0, v0, select(c1, v1, std::forward<Args>(args)...));
822}
823template<typename... Args>
824inline Tuple select(const Expr &c0, const Tuple &v0, const Expr &c1, const Tuple &v1, Args &&...args) {
825 return select(c0, v0, select(c1, v1, std::forward<Args>(args)...));
826}
827// @}
828
829/** select applied to FuncRefs (e.g. select(x < 100, f(x), g(x))) is assumed to
830 * return an Expr. A runtime error is produced if this is applied to
831 * tuple-valued Funcs. In that case you should explicitly cast the second and
832 * third args to Tuple to remove the ambiguity. */
833// @{
834Expr select(const Expr &condition, const FuncRef &true_value, const FuncRef &false_value);
835template<typename... Args>
836inline Expr select(const Expr &c0, const FuncRef &v0, const Expr &c1, const FuncRef &v1, Args &&...args) {
837 return select(c0, v0, select(c1, v1, std::forward<Args>(args)...));
838}
839// @}
840
841/** Oftentimes we want to pack a list of expressions with the same type
842 * into a channel dimension, e.g.,
843 * img(x, y, c) = select(c == 0, 100, // Red
844 * c == 1, 50, // Green
845 * 25); // Blue
846 * This is tedious when the list is long. The following function
847 * provide convinent syntax that allow one to write:
848 * img(x, y, c) = mux(c, {100, 50, 25});
849 *
850 * As with the select equivalent, if the first argument (the index) is
851 * out of range, the expression evaluates to the last value.
852 */
853// @{
854Expr mux(const Expr &id, const std::initializer_list<Expr> &values);
855Expr mux(const Expr &id, const std::vector<Expr> &values);
856Expr mux(const Expr &id, const Tuple &values);
857Expr mux(const Expr &id, const std::initializer_list<FuncRef> &values);
858Tuple mux(const Expr &id, const std::initializer_list<Tuple> &values);
859Tuple mux(const Expr &id, const std::vector<Tuple> &values);
860// @}
861
862/** Return the sine of a floating-point expression. If the argument is
863 * not floating-point, it is cast to Float(32). Does not vectorize
864 * well. */
866
867/** Return the arcsine of a floating-point expression. If the argument
868 * is not floating-point, it is cast to Float(32). Does not vectorize
869 * well. */
871
872/** Return the cosine of a floating-point expression. If the argument
873 * is not floating-point, it is cast to Float(32). Does not vectorize
874 * well. */
876
877/** Return the arccosine of a floating-point expression. If the
878 * argument is not floating-point, it is cast to Float(32). Does not
879 * vectorize well. */
881
882/** Return the tangent of a floating-point expression. If the argument
883 * is not floating-point, it is cast to Float(32). Does not vectorize
884 * well. */
886
887/** Return the arctangent of a floating-point expression. If the
888 * argument is not floating-point, it is cast to Float(32). Does not
889 * vectorize well. */
891
892/** Return the angle of a floating-point gradient. If the argument is
893 * not floating-point, it is cast to Float(32). Does not vectorize
894 * well. */
896
897/** Return the hyperbolic sine of a floating-point expression. If the
898 * argument is not floating-point, it is cast to Float(32). Does not
899 * vectorize well. */
901
902/** Return the hyperbolic arcsinhe of a floating-point expression. If
903 * the argument is not floating-point, it is cast to Float(32). Does
904 * not vectorize well. */
906
907/** Return the hyperbolic cosine of a floating-point expression. If
908 * the argument is not floating-point, it is cast to Float(32). Does
909 * not vectorize well. */
911
912/** Return the hyperbolic arccosine of a floating-point expression.
913 * If the argument is not floating-point, it is cast to
914 * Float(32). Does not vectorize well. */
916
917/** Return the hyperbolic tangent of a floating-point expression. If
918 * the argument is not floating-point, it is cast to Float(32). Does
919 * not vectorize well. */
921
922/** Return the hyperbolic arctangent of a floating-point expression.
923 * If the argument is not floating-point, it is cast to
924 * Float(32). Does not vectorize well. */
926
927/** Return the square root of a floating-point expression. If the
928 * argument is not floating-point, it is cast to Float(32). Typically
929 * vectorizes cleanly. */
931
932/** Return the square root of the sum of the squares of two
933 * floating-point expressions. If the argument is not floating-point,
934 * it is cast to Float(32). Vectorizes cleanly. */
935Expr hypot(const Expr &x, const Expr &y);
936
937/** Return the exponential of a floating-point expression. If the
938 * argument is not floating-point, it is cast to Float(32). For
939 * Float(64) arguments, this calls the system exp function, and does
940 * not vectorize well. For Float(32) arguments, this function is
941 * vectorizable, does the right thing for extremely small or extremely
942 * large inputs, and is accurate up to the last bit of the
943 * mantissa. Vectorizes cleanly. */
945
946/** Return the logarithm of a floating-point expression. If the
947 * argument is not floating-point, it is cast to Float(32). For
948 * Float(64) arguments, this calls the system log function, and does
949 * not vectorize well. For Float(32) arguments, this function is
950 * vectorizable, does the right thing for inputs <= 0 (returns -inf or
951 * nan), and is accurate up to the last bit of the
952 * mantissa. Vectorizes cleanly. */
954
955/** Return one floating point expression raised to the power of
956 * another. The type of the result is given by the type of the first
957 * argument. If the first argument is not a floating-point type, it is
958 * cast to Float(32). For Float(32), cleanly vectorizable, and
959 * accurate up to the last few bits of the mantissa. Gets worse when
960 * approaching overflow. Vectorizes cleanly. */
962
963/** Evaluate the error function erf. Only available for
964 * Float(32). Accurate up to the last three bits of the
965 * mantissa. Vectorizes cleanly. */
966Expr erf(const Expr &x);
967
968/** Fast vectorizable approximation to some trigonometric functions for Float(32).
969 * Absolute approximation error is less than 1e-5. */
970// @{
973// @}
974
975/** Fast approximate cleanly vectorizable log for Float(32). Returns
976 * nonsense for x <= 0.0f. Accurate up to the last 5 bits of the
977 * mantissa. Vectorizes cleanly. */
979
980/** Fast approximate cleanly vectorizable exp for Float(32). Returns
981 * nonsense for inputs that would overflow or underflow. Typically
982 * accurate up to the last 5 bits of the mantissa. Gets worse when
983 * approaching overflow. Vectorizes cleanly. */
985
986/** Fast approximate cleanly vectorizable pow for Float(32). Returns
987 * nonsense for x < 0.0f. Accurate up to the last 5 bits of the
988 * mantissa for typical exponents. Gets worse when approaching
989 * overflow. Vectorizes cleanly. */
991
992/** Fast approximate inverse for Float(32). Corresponds to the rcpps
993 * instruction on x86, and the vrecpe instruction on ARM. Vectorizes
994 * cleanly. Note that this can produce slightly different results
995 * across different implementations of the same architecture (e.g. AMD vs Intel),
996 * even when strict_float is enabled. */
998
999/** Fast approximate inverse square root for Float(32). Corresponds to
1000 * the rsqrtps instruction on x86, and the vrsqrte instruction on
1001 * ARM. Vectorizes cleanly. Note that this can produce slightly different results
1002 * across different implementations of the same architecture (e.g. AMD vs Intel),
1003 * even when strict_float is enabled. */
1005
1006/** Return the greatest whole number less than or equal to a
1007 * floating-point expression. If the argument is not floating-point,
1008 * it is cast to Float(32). The return value is still in floating
1009 * point, despite being a whole number. Vectorizes cleanly. */
1011
1012/** Return the least whole number greater than or equal to a
1013 * floating-point expression. If the argument is not floating-point,
1014 * it is cast to Float(32). The return value is still in floating
1015 * point, despite being a whole number. Vectorizes cleanly. */
1017
1018/** Return the whole number closest to a floating-point expression. If the
1019 * argument is not floating-point, it is cast to Float(32). The return value is
1020 * still in floating point, despite being a whole number. On ties, we round
1021 * towards the nearest even integer. Note that this is not the same as
1022 * std::round in C, which rounds away from zero. On platforms without a native
1023 * instruction for this, it is emulated, and may be more expensive than
1024 * cast<int>(x + 0.5f) or similar. */
1026
1027/** Return the integer part of a floating-point expression. If the argument is
1028 * not floating-point, it is cast to Float(32). The return value is still in
1029 * floating point, despite being a whole number. Vectorizes cleanly. */
1031
1032/** Returns true if the argument is a Not a Number (NaN). Requires a
1033 * floating point argument. Vectorizes cleanly.
1034 * Note that the Expr passed in will be evaluated in strict_float mode,
1035 * regardless of whether strict_float mode is enabled in the current Target. */
1037
1038/** Returns true if the argument is Inf or -Inf. Requires a
1039 * floating point argument. Vectorizes cleanly.
1040 * Note that the Expr passed in will be evaluated in strict_float mode,
1041 * regardless of whether strict_float mode is enabled in the current Target. */
1043
1044/** Returns true if the argument is a finite value (ie, neither NaN nor Inf).
1045 * Requires a floating point argument. Vectorizes cleanly.
1046 * Note that the Expr passed in will be evaluated in strict_float mode,
1047 * regardless of whether strict_float mode is enabled in the current Target. */
1049
1050/** Return the fractional part of a floating-point expression. If the argument
1051 * is not floating-point, it is cast to Float(32). The return value has the
1052 * same sign as the original expression. Vectorizes cleanly. */
1053Expr fract(const Expr &x);
1054
1055/** Reinterpret the bits of one value as another type. */
1057
1058template<typename T>
1060 return reinterpret(type_of<T>(), std::move(e));
1061}
1062
1063/** Return the bitwise and of two expressions (which need not have the
1064 * same type). The result type is the wider of the two expressions.
1065 * Only integral types are allowed and both expressions must be signed
1066 * or both must be unsigned. */
1068
1069/** Return the bitwise and of an expression and an integer. The type
1070 * of the result is the type of the expression argument. */
1071// @{
1074// @}
1075
1076/** Return the bitwise or of two expressions (which need not have the
1077 * same type). The result type is the wider of the two expressions.
1078 * Only integral types are allowed and both expressions must be signed
1079 * or both must be unsigned. */
1081
1082/** Return the bitwise or of an expression and an integer. The type of
1083 * the result is the type of the expression argument. */
1084// @{
1087// @}
1088
1089/** Return the bitwise xor of two expressions (which need not have the
1090 * same type). The result type is the wider of the two expressions.
1091 * Only integral types are allowed and both expressions must be signed
1092 * or both must be unsigned. */
1094
1095/** Return the bitwise xor of an expression and an integer. The type
1096 * of the result is the type of the expression argument. */
1097// @{
1100// @}
1101
1102/** Return the bitwise not of an expression. */
1104
1105/** Shift the bits of an integer value left. This is actually less
1106 * efficient than multiplying by 2^n, because Halide's optimization
1107 * passes understand multiplication, and will compile it to
1108 * shifting. This operator is only for if you really really need bit
1109 * shifting (e.g. because the exponent is a run-time parameter). The
1110 * type of the result is equal to the type of the first argument. Both
1111 * arguments must have integer type. */
1112// @{
1115// @}
1116
1117/** Shift the bits of an integer value right. Does sign extension for
1118 * signed integers. This is less efficient than dividing by a power of
1119 * two. Halide's definition of division (always round to negative
1120 * infinity) means that all divisions by powers of two get compiled to
1121 * bit-shifting, and Halide's optimization routines understand
1122 * division and can work with it. The type of the result is equal to
1123 * the type of the first argument. Both arguments must have integer
1124 * type. */
1125// @{
1128// @}
1129
1130/** Linear interpolate between the two values according to a weight.
1131 * \param zero_val The result when weight is 0
1132 * \param one_val The result when weight is 1
1133 * \param weight The interpolation amount
1134 *
1135 * Both zero_val and one_val must have the same type. All types are
1136 * supported, including bool.
1137 *
1138 * The weight is treated as its own type and must be float or an
1139 * unsigned integer type. It is scaled to the bit-size of the type of
1140 * x and y if they are integer, or converted to float if they are
1141 * float. Integer weights are converted to float via division by the
1142 * full-range value of the weight's type. Floating-point weights used
1143 * to interpolate between integer values must be between 0.0f and
1144 * 1.0f, and an error may be signaled if it is not provably so. (clamp
1145 * operators can be added to provide proof. Currently an error is only
1146 * signalled for constant weights.)
1147 *
1148 * For integer linear interpolation, out of range values cannot be
1149 * represented. In particular, weights that are conceptually less than
1150 * 0 or greater than 1.0 are not representable. As such the result is
1151 * always between x and y (inclusive of course). For lerp with
1152 * floating-point values and floating-point weight, the full range of
1153 * a float is valid, however underflow and overflow can still occur.
1154 *
1155 * Ordering is not required between zero_val and one_val:
1156 * lerp(42, 69, .5f) == lerp(69, 42, .5f) == 56
1157 *
1158 * Results for integer types are for exactly rounded arithmetic. As
1159 * such, there are cases where 16-bit and float differ because 32-bit
1160 * floating-point (float) does not have enough precision to produce
1161 * the exact result. (Likely true for 32-bit integer
1162 * vs. double-precision floating-point as well.)
1163 *
1164 * At present, double precision and 64-bit integers are not supported.
1165 *
1166 * Generally, lerp will vectorize as if it were an operation on a type
1167 * twice the bit size of the inferred type for x and y.
1168 *
1169 * Some examples:
1170 * \code
1171 *
1172 * // Since Halide does not have direct type delcarations, casts
1173 * // below are used to indicate the types of the parameters.
1174 * // Such casts not required or expected in actual code where types
1175 * // are inferred.
1176 *
1177 * lerp(cast<float>(x), cast<float>(y), cast<float>(w)) ->
1178 * x * (1.0f - w) + y * w
1179 *
1180 * lerp(cast<uint8_t>(x), cast<uint8_t>(y), cast<uint8_t>(w)) ->
1181 * cast<uint8_t>(cast<uint8_t>(x) * (1.0f - cast<uint8_t>(w) / 255.0f) +
1182 * cast<uint8_t>(y) * cast<uint8_t>(w) / 255.0f + .5f)
1183 *
1184 * // Note addition in Halide promoted uint8_t + int8_t to int16_t already,
1185 * // the outer cast is added for clarity.
1186 * lerp(cast<uint8_t>(x), cast<int8_t>(y), cast<uint8_t>(w)) ->
1187 * cast<int16_t>(cast<uint8_t>(x) * (1.0f - cast<uint8_t>(w) / 255.0f) +
1188 * cast<int8_t>(y) * cast<uint8_t>(w) / 255.0f + .5f)
1189 *
1190 * lerp(cast<int8_t>(x), cast<int8_t>(y), cast<float>(w)) ->
1191 * cast<int8_t>(cast<int8_t>(x) * (1.0f - cast<float>(w)) +
1192 * cast<int8_t>(y) * cast<uint8_t>(w))
1193 *
1194 * \endcode
1195 * */
1196Expr lerp(Expr zero_val, Expr one_val, Expr weight);
1197
1198/** Count the number of set bits in an expression. */
1200
1201/** Count the number of leading zero bits in an expression. If the expression is
1202 * zero, the result is the number of bits in the type. */
1204
1205/** Count the number of trailing zero bits in an expression. If the expression is
1206 * zero, the result is the number of bits in the type. */
1208
1209/** Divide two integers, rounding towards zero. This is the typical
1210 * behavior of most hardware architectures, which differs from
1211 * Halide's division operator, which is Euclidean (rounds towards
1212 * -infinity). Will throw a runtime error if y is zero, or if y is -1
1213 * and x is the minimum signed integer. */
1215
1216/** Compute the remainder of dividing two integers, when division is
1217 * rounding toward zero. This is the typical behavior of most hardware
1218 * architectures, which differs from Halide's mod operator, which is
1219 * Euclidean (produces the remainder when division rounds towards
1220 * -infinity). Will throw a runtime error if y is zero. */
1222
1223/** Return a random variable representing a uniformly distributed
1224 * float in the half-open interval [0.0f, 1.0f). For random numbers of
1225 * other types, use lerp with a random float as the last parameter.
1226 *
1227 * Optionally takes a seed.
1228 *
1229 * Note that:
1230 \code
1231 Expr x = random_float();
1232 Expr y = x + x;
1233 \endcode
1234 *
1235 * is very different to
1236 *
1237 \code
1238 Expr y = random_float() + random_float();
1239 \endcode
1240 *
1241 * The first doubles a random variable, and the second adds two
1242 * independent random variables.
1243 *
1244 * A given random variable takes on a unique value that depends
1245 * deterministically on the pure variables of the function they belong
1246 * to, the identity of the function itself, and which definition of
1247 * the function it is used in. They are, however, shared across tuple
1248 * elements.
1249 *
1250 * This function vectorizes cleanly.
1251 */
1253
1254/** Return a random variable representing a uniformly distributed
1255 * unsigned 32-bit integer. See \ref random_float. Vectorizes cleanly. */
1257
1258/** Return a random variable representing a uniformly distributed
1259 * 32-bit integer. See \ref random_float. Vectorizes cleanly. */
1261
1262/** Create an Expr that prints out its value whenever it is
1263 * evaluated. It also prints out everything else in the arguments
1264 * list, separated by spaces. This can include string literals. */
1265//@{
1266Expr print(const std::vector<Expr> &values);
1267
1268template<typename... Args>
1269inline HALIDE_NO_USER_CODE_INLINE Expr print(Expr a, Args &&...args) {
1270 std::vector<Expr> collected_args = {std::move(a)};
1271 Internal::collect_print_args(collected_args, std::forward<Args>(args)...);
1272 return print(collected_args);
1273}
1274//@}
1275
1276/** Create an Expr that prints whenever it is evaluated, provided that
1277 * the condition is true. */
1278// @{
1279Expr print_when(Expr condition, const std::vector<Expr> &values);
1280
1281template<typename... Args>
1282inline HALIDE_NO_USER_CODE_INLINE Expr print_when(Expr condition, Expr a, Args &&...args) {
1283 std::vector<Expr> collected_args = {std::move(a)};
1284 Internal::collect_print_args(collected_args, std::forward<Args>(args)...);
1285 return print_when(std::move(condition), collected_args);
1286}
1287
1288// @}
1289
1290/** Create an Expr that that guarantees a precondition.
1291 * If 'condition' is true, the return value is equal to the first Expr.
1292 * If 'condition' is false, halide_error() is called, and the return value
1293 * is arbitrary. Any additional arguments after the first Expr are stringified
1294 * and passed as a user-facing message to halide_error(), similar to print().
1295 *
1296 * Note that this essentially *always* inserts a runtime check into the
1297 * generated code (except when the condition can be proven at compile time);
1298 * as such, it should be avoided inside inner loops, except for debugging
1299 * or testing purposes. Note also that it does not vectorize cleanly (vector
1300 * values will be scalarized for the check).
1301 *
1302 * However, using this to make assertions about (say) input values
1303 * can be useful, both in terms of correctness and (potentially) in terms
1304 * of code generation, e.g.
1305 \code
1306 Param<int> p;
1307 Expr y = require(p > 0, p);
1308 \endcode
1309 * will allow the optimizer to assume positive, nonzero values for y.
1310 */
1311// @{
1312Expr require(Expr condition, const std::vector<Expr> &values);
1313
1314template<typename... Args>
1315inline HALIDE_NO_USER_CODE_INLINE Expr require(Expr condition, Expr value, Args &&...args) {
1316 std::vector<Expr> collected_args = {std::move(value)};
1317 Internal::collect_print_args(collected_args, std::forward<Args>(args)...);
1318 return require(std::move(condition), collected_args);
1319}
1320// @}
1321
1322/** Return an undef value of the given type. Halide skips stores that
1323 * depend on undef values, so you can use this to mean "do not modify
1324 * this memory location". This is an escape hatch that can be used for
1325 * several things:
1326 *
1327 * You can define a reduction with no pure step, by setting the pure
1328 * step to undef. Do this only if you're confident that the update
1329 * steps are sufficient to correctly fill in the domain.
1330 *
1331 * For a tuple-valued reduction, you can write an update step that
1332 * only updates some tuple elements.
1333 *
1334 * You can define single-stage pipeline that only has update steps,
1335 * and depends on the values already in the output buffer.
1336 *
1337 * Use this feature with great caution, as you can use it to load from
1338 * uninitialized memory.
1339 */
1341
1342template<typename T>
1343inline Expr undef() {
1344 return undef(type_of<T>());
1345}
1346
1347namespace Internal {
1348
1349/** Return an expression that should never be evaluated. Expressions
1350 * that depend on unreachabale values are also unreachable, and
1351 * statements that execute unreachable expressions are also considered
1352 * unreachable. */
1354
1355template<typename T>
1357 return unreachable(type_of<T>());
1358}
1359
1360} // namespace Internal
1361
1362/** Control the values used in the memoization cache key for memoize.
1363 * Normally parameters and other external dependencies are
1364 * automatically inferred and added to the cache key. The memoize_tag
1365 * operator allows computing one expression and using either the
1366 * computed value, or one or more other expressions in the cache key
1367 * instead of the parameter dependencies of the computation. The
1368 * single argument version is completely safe in that the cache key
1369 * will use the actual computed value -- it is difficult or imposible
1370 * to produce erroneous caching this way. The more-than-one argument
1371 * version allows generating cache keys that do not uniquely identify
1372 * the computation and thus can result in caching errors.
1373 *
1374 * A potential use for the single argument version is to handle a
1375 * floating-point parameter that is quantized to a small
1376 * integer. Mutliple values of the float will produce the same integer
1377 * and moving the caching to using the integer for the key is more
1378 * efficient.
1379 *
1380 * The main use for the more-than-one argument version is to provide
1381 * cache key information for Handles and ImageParams, which otherwise
1382 * are not allowed inside compute_cached operations. E.g. when passing
1383 * a group of parameters to an external array function via a Handle,
1384 * memoize_tag can be used to isolate the actual values used by that
1385 * computation. If an ImageParam is a constant image with a persistent
1386 * digest, memoize_tag can be used to key computations using that image
1387 * on the digest. */
1388// @{
1389template<typename... Args>
1390inline HALIDE_NO_USER_CODE_INLINE Expr memoize_tag(Expr result, Args &&...args) {
1391 std::vector<Expr> collected_args{std::forward<Args>(args)...};
1392 return Internal::memoize_tag_helper(std::move(result), collected_args);
1393}
1394// @}
1395
1396/** Expressions tagged with this intrinsic are considered to be part
1397 * of the steady state of some loop with a nasty beginning and end
1398 * (e.g. a boundary condition). When Halide encounters likely
1399 * intrinsics, it splits the containing loop body into three, and
1400 * tries to simplify down all conditions that lead to the likely. For
1401 * example, given the expression: select(x < 1, bar, x > 10, bar,
1402 * likely(foo)), Halide will split the loop over x into portions where
1403 * x < 1, 1 <= x <= 10, and x > 10.
1404 *
1405 * You're unlikely to want to call this directly. You probably want to
1406 * use the boundary condition helpers in the BoundaryConditions
1407 * namespace instead.
1408 */
1410
1411/** Equivalent to likely, but only triggers a loop partitioning if
1412 * found in an innermost loop. */
1414
1415/** Cast an expression to the halide type corresponding to the C++
1416 * type T. As part of the cast, clamp to the minimum and maximum
1417 * values of the result type. */
1418template<typename T>
1420 return saturating_cast(type_of<T>(), std::move(e));
1421}
1422
1423/** Cast an expression to a new type, clamping to the minimum and
1424 * maximum values of the result type. */
1426
1427/** Makes a best effort attempt to preserve IEEE floating-point
1428 * semantics in evaluating an expression. May not be implemented for
1429 * all backends. (E.g. it is difficult to do this for C++ code
1430 * generation as it depends on the compiler flags used to compile the
1431 * generated code. */
1433
1434/** Create an Expr that that promises another Expr is clamped but do
1435 * not generate code to check the assertion or modify the value. No
1436 * attempt is made to prove the bound at compile time. (If it is
1437 * proved false as a result of something else, an error might be
1438 * generated, but it is also possible the compiler will crash.) The
1439 * promised bound is used in bounds inference so it will allow
1440 * satisfying bounds checks as well as possibly aiding optimization.
1441 *
1442 * unsafe_promise_clamped returns its first argument, the Expr 'value'
1443 *
1444 * This is a very easy way to make Halide generate erroneous code if
1445 * the bound promises is not kept. Use sparingly when there is no
1446 * other way to convey the information to the compiler and it is
1447 * required for a valuable optimization.
1448 *
1449 * Unsafe promises can be checked by turning on
1450 * Target::CheckUnsafePromises. This is intended for debugging only.
1451 */
1452Expr unsafe_promise_clamped(const Expr &value, const Expr &min, const Expr &max);
1453
1454namespace Internal {
1455/**
1456 * FOR INTERNAL USE ONLY.
1457 *
1458 * An entirely unchecked version of unsafe_promise_clamped, used
1459 * inside the compiler as an annotation of the known bounds of an Expr
1460 * when it has proved something is bounded and wants to record that
1461 * fact for later passes (notably bounds inference) to exploit. This
1462 * gets introduced by GuardWithIf tail strategies, because the bounds
1463 * machinery has a hard time exploiting if statement conditions.
1464 *
1465 * Unlike unsafe_promise_clamped, this expression is
1466 * context-dependent, because 'value' might be statically bounded at
1467 * some point in the IR (e.g. due to a containing if statement), but
1468 * not elsewhere.
1469 *
1470 * This intrinsic always evaluates to its first argument. If this value is
1471 * used by a side-effecting operation and it is outside the range specified
1472 * by its second and third arguments, behavior is undefined. The compiler can
1473 * therefore assume that the value is within the range given and optimize
1474 * accordingly. Note that this permits promise_clamped to evaluate to
1475 * something outside of the range, provided that this value is not used.
1476 *
1477 * Note that this produces an intrinsic that is marked as 'pure' and thus is
1478 * allowed to be hoisted, etc.; thus, extra care must be taken with its use.
1479 **/
1480Expr promise_clamped(const Expr &value, const Expr &min, const Expr &max);
1481} // namespace Internal
1482
1483/** Scatter and gather are used for update definition which must store
1484 * multiple values to distinct locations at the same time. The
1485 * multiple expressions on the right-hand-side are bundled together
1486 * into a "gather", which must match a "scatter" the the same number
1487 * of arguments on the left-hand-size. For example, to store the
1488 * values 1 and 2 to the locations (x, y, 3) and (x, y, 4),
1489 * respectively:
1490 *
1491\code
1492f(x, y, scatter(3, 4)) = gather(1, 2);
1493\endcode
1494 *
1495 * The result of gather or scatter can be treated as an
1496 * expression. Any containing operations on it can be assumed to
1497 * distribute over the elements. If two gather expressions are
1498 * combined with an arithmetic operator (e.g. added), they combine
1499 * element-wise. The following example stores the values 2 * x, 2 * y,
1500 * and 2 * c to the locations (x + 1, y, c), (x, y + 3, c), and (x, y,
1501 * c + 2) respectively:
1502 *
1503\code
1504f(x + scatter(1, 0, 0), y + scatter(0, 3, 0), c + scatter(0, 0, 2)) = 2 * gather(x, y, c);
1505\endcode
1506*
1507* Repeated values in the scatter cause multiple stores to the same
1508* location. The stores happen in order from left to right, so the
1509* rightmost value wins. The following code is equivalent to f(x) = 5
1510*
1511\code
1512f(scatter(x, x)) = gather(3, 5);
1513\endcode
1514*
1515* Gathers are most useful for algorithms which require in-place
1516* swapping or permutation of multiple elements, or other kinds of
1517* in-place mutations that require loading multiple inputs, doing some
1518* operations to them jointly, then storing them again. The following
1519* update definition swaps the values of f at locations 3 and 5 if an
1520* input parameter p is true:
1521*
1522\code
1523f(scatter(3, 5)) = f(select(p, gather(5, 3), gather(3, 5)));
1524\endcode
1525*
1526* For more examples of the use of scatter and gather, see
1527* test/correctness/multiple_scatter.cpp
1528*
1529* It is not currently possible to use scatter and gather to write an
1530* update definition in which the *number* of values loaded or stored
1531* varies, as the size of the scatter/gather packet must be fixed a
1532* compile-time. A workaround is to make the unwanted extra operations
1533* a redundant copy of the last operation, which will be
1534* dead-code-eliminated by the compiler. For example, the following
1535* update definition swaps the values at locations 3 and 5 when the
1536* parameter p is true, and rotates the values at locations 1, 2, and 3
1537* when it is false. The load from 3 and store to 5 will be redundantly
1538* repeated:
1539*
1540\code
1541f(select(p, scatter(3, 5, 5), scatter(1, 2, 3))) = f(select(p, gather(5, 3, 3), gather(2, 3, 1)));
1542\endcode
1543*
1544* Note that in the p == true case, we redudantly load from 3 and write
1545* to 5 twice.
1546*/
1547//@{
1548Expr scatter(const std::vector<Expr> &args);
1549Expr gather(const std::vector<Expr> &args);
1550
1551template<typename... Args>
1552Expr scatter(const Expr &e, Args &&...args) {
1553 return scatter({e, std::forward<Args>(args)...});
1554}
1555
1556template<typename... Args>
1557Expr gather(const Expr &e, Args &&...args) {
1558 return gather({e, std::forward<Args>(args)...});
1559}
1560// @}
1561
1562/** Extract a contiguous subsequence of the bits of 'e', starting at the bit
1563 * index given by 'lsb', where zero is the least-significant bit, returning a
1564 * value of type 't'. Any out-of-range bits requested are filled with zeros.
1565 *
1566 * extract_bits is especially useful when one wants to load a small vector of a
1567 * wide type, and treat it as a larger vector of a smaller type. For example,
1568 * loading a vector of 32 uint8 values from a uint32 Func can be done as
1569 * follows:
1570\code
1571f8(x) = extract_bits<uint8_t>(f32(x/4), 8*(x%4));
1572f8.align_bounds(x, 4).vectorize(x, 32);
1573\endcode
1574 * Note that the align_bounds call is critical so that the narrow Exprs are
1575 * aligned to the wider Exprs. This makes the x%4 term collapse to a
1576 * constant. If f8 is an output Func, then constraining the min value of x to be
1577 * a known multiple of four would also be sufficient, e.g. via:
1578\code
1579f8.output_buffer().dim(0).set_min(0);
1580\endcode
1581 *
1582 * See test/correctness/extract_concat_bits.cpp for a complete example. */
1583// @{
1584Expr extract_bits(Type t, const Expr &e, const Expr &lsb);
1585
1586template<typename T>
1587Expr extract_bits(const Expr &e, const Expr &lsb) {
1588 return extract_bits(type_of<T>(), e, lsb);
1589}
1590// @}
1591
1592/** Given a number of Exprs of the same type, concatenate their bits producing a
1593 * single Expr of the same type code of the input but with more bits. The
1594 * number of arguments must be a power of two.
1595 *
1596 * concat_bits is especially useful when one wants to treat a Func containing
1597 * values of a narrow type as a Func containing fewer values of a wider
1598 * type. For example, the following code reinterprets vectors of 32 uint8 values
1599 * as a vector of 8 uint32s:
1600 *
1601\code
1602f32(x) = concat_bits({f8(4*x), f8(4*x + 1), f8(4*x + 2), f8(4*x + 3)});
1603f32.vectorize(x, 8);
1604\endcode
1605 *
1606 * See test/correctness/extract_concat_bits.cpp for a complete example.
1607 */
1608Expr concat_bits(const std::vector<Expr> &e);
1609
1610/** Below is a collection of intrinsics for fixed-point programming. Most of
1611 * them can be expressed via other means, but this is more natural for some, as
1612 * it avoids ghost widened intermediates that don't (or shouldn't) actually show
1613 * up in codegen, and doesn't rely on pattern-matching inside the compiler to
1614 * succeed to get good instruction selection.
1615 *
1616 * The semantics of each call are defined in terms of a non-existent 'widen' and
1617 * 'narrow' operators, which stand in for casts that double or halve the
1618 * bit-width of a type respectively.
1619 */
1620
1621/** Compute a + widen(b). */
1623
1624/** Compute a * widen(b). */
1626
1627/** Compute a - widen(b). */
1629
1630/** Compute widen(a) + widen(b). */
1632
1633/** Compute widen(a) * widen(b). a and b may have different signedness, in which
1634 * case the result is signed. */
1636
1637/** Compute widen(a) - widen(b). The result is always signed. */
1639
1640/** Compute widen(a) << b. */
1641//@{
1644//@}
1645
1646/** Compute widen(a) >> b. */
1647//@{
1650//@}
1651
1652/** Compute saturating_narrow(widening_add(a, (1 >> min(b, 0)) / 2) << b).
1653 * When b is positive indicating a left shift, the rounding term is zero. */
1654//@{
1657//@}
1658
1659/** Compute saturating_narrow(widening_add(a, (1 << max(b, 0)) / 2) >> b).
1660 * When b is negative indicating a left shift, the rounding term is zero. */
1661//@{
1664//@}
1665
1666/** Compute saturating_narrow(widen(a) + widen(b)) */
1668
1669/** Compute saturating_narrow(widen(a) - widen(b)) */
1671
1672/** Compute narrow((widen(a) + widen(b)) / 2) */
1674
1675/** Compute narrow((widen(a) + widen(b) + 1) / 2) */
1677
1678/** Compute narrow((widen(a) - widen(b)) / 2) */
1680
1681/** Compute saturating_narrow(shift_right(widening_mul(a, b), q)) */
1682//@{
1685//@}
1686
1687/** Compute saturating_narrow(rounding_shift_right(widening_mul(a, b), q)) */
1688//@{
1691//@}
1692
1693/** Return a boolean Expr for the corresponding field of the Target
1694 * being used during lowering; they can be useful in writing library
1695 * code without having to plumb a Target through call sites, so that you
1696 * can do things like
1697 \code
1698 Expr e = select(target_arch_is(Target::ARM), something, something_else);
1699 \endcode
1700 * Note that this doesn't do any checking at runtime to verify that the Target
1701 * is valid for the current hardware configuration.
1702 */
1703//@{
1707//@}
1708
1709/** Return the bit width of the Target used during lowering; this can be useful
1710 * in writing library code without having to plumb a Target through call sites,
1711 * so that you can do things like
1712 \code
1713 Expr e = select(target_bits() == 32, something, something_else);
1714 \endcode
1715 * Note that this doesn't do any checking at runtime to verify that the Target
1716 * is valid for the current hardware configuration.
1717 */
1719
1720/** Return the natural vector width for the given Type for the Target
1721 * being used during lowering; this can be useful in writing library
1722 * code without having to plumb a Target through call sites, so that you
1723 * can do things like
1724 \code
1725 f.vectorize(x, target_natural_vector_size(Float(32)));
1726 \endcode
1727 * Note that this doesn't do any checking at runtime to verify that the Target
1728 * is valid for the current hardware configuration.
1729 */
1730//@{
1732template<typename data_t>
1736//@}
1737
1738} // namespace Halide
1739
1740#endif
Base classes for Halide expressions (Halide::Expr) and statements (Halide::Internal::Stmt)
Defines the structure that describes a Halide target.
Defines Tuple - the front-end handle on small arrays of expressions.
#define HALIDE_NO_USER_CODE_INLINE
Definition Util.h:47
A fragment of front-end syntax of the form f(x, y, z), where x, y, z are Vars or Exprs.
Definition Func.h:491
Create a small array of Exprs for defining and calling functions with multiple outputs.
Definition Tuple.h:18
Expr make_one(Type t)
Construct the representation of one in the given type.
T div_imp(T a, T b)
Definition IROperator.h:268
bool is_const_zero(const Expr &e)
Is the expression a const (as defined by is_const), and also equal to zero (in all lanes,...
Expr memoize_tag_helper(Expr result, const std::vector< Expr > &cache_key_values)
const double * as_const_float(const Expr &e)
If an expression is a FloatImm or a Broadcast of a FloatImm, return a pointer to its value.
Expr make_zero(Type t)
Construct the representation of zero in the given type.
bool 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,...
bool is_undef(const Expr &e)
Is the expression an undef.
Expr requirement_failed_error(Expr condition, const std::vector< Expr > &args)
Expr make_two(Type t)
Construct the representation of two in the given type.
void check_representable(Type t, int64_t val)
Check if a constant value can be correctly represented as the given type.
Expr halide_erf(const Expr &a)
bool is_const_one(const Expr &e)
Is the expression a const (as defined by is_const), and also equal to one (in all lanes,...
void match_types(Expr &a, Expr &b)
Coerce the two expressions to have the same type, using C-style casting rules.
double div_imp< double >(double a, double b)
Definition IROperator.h:309
Expr halide_exp(const Expr &a)
Expr make_const(Type t, int64_t val)
Construct an immediate of the given type from any numeric C++ type.
const int64_t * as_const_int(const Expr &e)
If an expression is an IntImm or a Broadcast of an IntImm, return a pointer to its value.
bool 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...
Expr const_true(int lanes=1)
Construct the constant boolean true.
bool is_signed_integer_overflow(const Expr &expr)
Check if an expression is a signed_integer_overflow.
T mod_imp(T a, T b)
Implementations of division and mod that are specific to Halide.
Definition IROperator.h:247
void reset_random_counters()
Reset the counters used for random-number seeds in random_float/int/uint.
Expr halide_log(const Expr &a)
Halide's vectorizable transcendentals.
bool is_pure(const Expr &e)
Does the expression 1) Take on the same value no matter where it appears in a Stmt,...
void split_into_ands(const Expr &cond, std::vector< Expr > &result)
Split a boolean condition into vector of ANDs.
Expr promise_clamped(const Expr &value, const Expr &min, const Expr &max)
FOR INTERNAL USE ONLY.
bool 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...
Expr unwrap_tags(const Expr &e)
If the expression is a tag helper call, remove it and return the tagged expression.
float div_imp< float >(float a, float b)
Definition IROperator.h:305
bool is_const_power_of_two_integer(const Expr &e, int *bits)
Is the expression a constant integer power of two.
Expr lossless_negate(const Expr &x)
Attempt to negate x without introducing new IR and without overflow.
const uint64_t * as_const_uint(const Expr &e)
If an expression is a UIntImm or a Broadcast of a UIntImm, return a pointer to its value.
Expr strided_ramp_base(const Expr &e, int stride=1)
If e is a ramp expression with stride, default 1, return the base, otherwise undefined.
Expr remove_promises(const Expr &e)
Return an Expr that is identical to the input Expr, but with all calls to promise_clamped() and unsaf...
Expr const_false(int lanes=1)
Construct the constant boolean false.
double mod_imp< double >(double a, double b)
Definition IROperator.h:299
Expr 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 make_bool(bool val, int lanes=1)
Construct a boolean constant from a C++ boolean value.
HALIDE_NO_USER_CODE_INLINE void collect_print_args(std::vector< Expr > &args)
Definition IROperator.h:343
void 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.
float mod_imp< float >(float a, float b)
Definition IROperator.h:293
Expr raise_to_integer_power(Expr a, int64_t b)
Raise an expression to an integer power by repeatedly multiplying it by itself.
Expr make_signed_integer_overflow(Type type)
Construct a unique signed_integer_overflow Expr.
bool is_const(const Expr &e)
Is the expression either an IntImm, a FloatImm, a StringImm, or a Cast of the same,...
Expr remove_likelies(const Expr &e)
Return an Expr that is identical to the input Expr, but with all calls to likely() and likely_if_inne...
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
auto operator>=(const Other &a, const GeneratorParam< T > &b) -> decltype(a >=(T) b)
Greater than or equal comparison between GeneratorParam<T> and any type that supports operator>= with...
Definition Generator.h:1104
Expr log(Expr x)
Return the logarithm of a floating-point expression.
Expr operator>>(Expr x, Expr y)
Shift the bits of an integer value right.
Expr ceil(Expr x)
Return the least whole number greater than or equal to a floating-point expression.
Expr widen_right_add(Expr a, Expr b)
Below is a collection of intrinsics for fixed-point programming.
Expr rounding_shift_right(Expr a, Expr b)
Compute saturating_narrow(widening_add(a, (1 << max(b, 0)) / 2) >> b).
Expr target_natural_vector_size()
HALIDE_NO_USER_CODE_INLINE Expr memoize_tag(Expr result, Args &&...args)
Control the values used in the memoization cache key for memoize.
Expr fast_log(const Expr &x)
Fast approximate cleanly vectorizable log for Float(32).
Expr count_leading_zeros(Expr x)
Count the number of leading zero bits in an expression.
Expr reinterpret(Type t, Expr e)
Reinterpret the bits of one value as another type.
Expr saturating_add(Expr a, Expr b)
Compute saturating_narrow(widen(a) + widen(b))
auto operator==(const Other &a, const GeneratorParam< T > &b) -> decltype(a==(T) b)
Equality comparison between GeneratorParam<T> and any type that supports operator== with T.
Definition Generator.h:1130
Expr fast_cos(const Expr &x)
Expr & operator*=(Expr &a, Expr b)
Modify the first expression to be the product of two expressions, without changing its type.
Expr random_uint(Expr seed=Expr())
Return a random variable representing a uniformly distributed unsigned 32-bit integer.
@ Internal
Not visible externally, similar to 'static' linkage in C.
Expr fract(const Expr &x)
Return the fractional part of a floating-point expression.
Expr halving_add(Expr a, Expr b)
Compute narrow((widen(a) + widen(b)) / 2)
Expr & operator-=(Expr &a, Expr b)
Modify the first expression to be the difference of two expressions, without changing its type.
auto operator<(const Other &a, const GeneratorParam< T > &b) -> decltype(a<(T) b)
Less than comparison between GeneratorParam<T> and any type that supports operator< with T.
Definition Generator.h:1091
Expr widening_shift_right(Expr a, Expr b)
Compute widen(a) >> b.
Type type_of()
Construct the halide equivalent of a C type.
Definition Type.h:572
auto operator*(const Other &a, const GeneratorParam< T > &b) -> decltype(a *(T) b)
Multiplication between GeneratorParam<T> and any type that supports operator* with T.
Definition Generator.h:1039
Expr trunc(Expr x)
Return the integer part of a floating-point expression.
Expr halving_sub(Expr a, Expr b)
Compute narrow((widen(a) - widen(b)) / 2)
auto operator||(const Other &a, const GeneratorParam< T > &b) -> decltype(a||(T) b)
Logical or between between GeneratorParam<T> and any type that supports operator|| with T.
Definition Generator.h:1173
Expr acosh(Expr x)
Return the hyperbolic arccosine of a floating-point expression.
Expr fast_inverse(Expr x)
Fast approximate inverse for Float(32).
Expr target_arch_is(Target::Arch arch)
Return a boolean Expr for the corresponding field of the Target being used during lowering; they can ...
Expr asin(Expr x)
Return the arcsine of a floating-point expression.
Expr rounding_shift_left(Expr a, Expr b)
Compute saturating_narrow(widening_add(a, (1 >> min(b, 0)) / 2) << b).
auto operator-(const Other &a, const GeneratorParam< T > &b) -> decltype(a -(T) b)
Subtraction between GeneratorParam<T> and any type that supports operator- with T.
Definition Generator.h:1026
Expr clamp(Expr a, const Expr &min_val, const Expr &max_val)
Clamps an expression to lie within the given bounds.
Expr hypot(const Expr &x, const Expr &y)
Return the square root of the sum of the squares of two floating-point expressions.
Expr popcount(Expr x)
Count the number of set bits in an expression.
Expr saturating_sub(Expr a, Expr b)
Compute saturating_narrow(widen(a) - widen(b))
Expr gather(const std::vector< Expr > &args)
Expr print_when(Expr condition, const std::vector< Expr > &values)
Create an Expr that prints whenever it is evaluated, provided that the condition is true.
Expr widening_shift_left(Expr a, Expr b)
Compute widen(a) << b.
Expr pow(Expr x, Expr y)
Return one floating point expression raised to the power of another.
Expr operator&(Expr x, Expr y)
Return the bitwise and of two expressions (which need not have the same type).
Expr undef()
auto operator!(const GeneratorParam< T > &a) -> decltype(!(T) a)
Not operator for GeneratorParam.
Definition Generator.h:1245
Expr lerp(Expr zero_val, Expr one_val, Expr weight)
Linear interpolate between the two values according to a weight.
Expr atan2(Expr y, Expr x)
Return the angle of a floating-point gradient.
Expr random_float(Expr seed=Expr())
Return a random variable representing a uniformly distributed float in the half-open interval [0....
Expr sin(Expr x)
Return the sine of a floating-point expression.
Expr 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 asser...
Expr rounding_halving_add(Expr a, Expr b)
Compute narrow((widen(a) + widen(b) + 1) / 2)
Expr 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',...
Expr 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 ...
Expr 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,...
Expr cosh(Expr x)
Return the hyperbolic cosine of a floating-point expression.
std::ostream & operator<<(std::ostream &stream, const Expr &)
Emit an expression on an output stream (such as std::cout) in human-readable form.
Type Int(int bits, int lanes=1)
Constructing a signed integer type.
Definition Type.h:541
Expr acos(Expr x)
Return the arccosine of a floating-point expression.
Expr fast_exp(const Expr &x)
Fast approximate cleanly vectorizable exp for Float(32).
Expr widening_add(Expr a, Expr b)
Compute widen(a) + widen(b).
Expr target_os_is(Target::OS os)
Expr cos(Expr x)
Return the cosine of a floating-point expression.
auto operator+(const Other &a, const GeneratorParam< T > &b) -> decltype(a+(T) b)
Addition between GeneratorParam<T> and any type that supports operator+ with T.
Definition Generator.h:1013
Expr min(const FuncRef &a, const FuncRef &b)
Explicit overloads of min and max for FuncRef.
Definition Func.h:597
Expr exp(Expr x)
Return the exponential of a floating-point expression.
Expr widen_right_mul(Expr a, Expr b)
Compute a * widen(b).
Expr absd(Expr a, Expr b)
Return the absolute difference between two values.
auto operator&&(const Other &a, const GeneratorParam< T > &b) -> decltype(a &&(T) b)
Logical and between between GeneratorParam<T> and any type that supports operator&& with T.
Definition Generator.h:1156
Expr fast_sin(const Expr &x)
Fast vectorizable approximation to some trigonometric functions for Float(32).
Expr fast_pow(Expr x, Expr y)
Fast approximate cleanly vectorizable pow for Float(32).
auto operator%(const Other &a, const GeneratorParam< T > &b) -> decltype(a %(T) b)
Modulo between GeneratorParam<T> and any type that supports operator% with T.
Definition Generator.h:1065
@ C
No name mangling.
Expr round(Expr x)
Return the whole number closest to a floating-point expression.
Expr 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 argum...
Expr count_trailing_zeros(Expr x)
Count the number of trailing zero bits in an expression.
Expr scatter(const std::vector< Expr > &args)
Scatter and gather are used for update definition which must store multiple values to distinct locati...
auto operator<=(const Other &a, const GeneratorParam< T > &b) -> decltype(a<=(T) b)
Less than or equal comparison between GeneratorParam<T> and any type that supports operator<= with T.
Definition Generator.h:1117
Expr rounding_mul_shift_right(Expr a, Expr b, Expr q)
Compute saturating_narrow(rounding_shift_right(widening_mul(a, b), q))
Expr random_int(Expr seed=Expr())
Return a random variable representing a uniformly distributed 32-bit integer.
Expr mod_round_to_zero(Expr x, Expr y)
Compute the remainder of dividing two integers, when division is rounding toward zero.
Expr strict_float(Expr e)
Makes a best effort attempt to preserve IEEE floating-point semantics in evaluating an expression.
Expr & operator/=(Expr &a, Expr b)
Modify the first expression to be the ratio of two expressions, without changing its type.
Expr widening_mul(Expr a, Expr b)
Compute widen(a) * widen(b).
auto operator>(const Other &a, const GeneratorParam< T > &b) -> decltype(a >(T) b)
Greater than comparison between GeneratorParam<T> and any type that supports operator> with T.
Definition Generator.h:1078
Expr is_nan(Expr x)
Returns true if the argument is a Not a Number (NaN).
Expr asinh(Expr x)
Return the hyperbolic arcsinhe of a floating-point expression.
Expr sqrt(Expr x)
Return the square root of a floating-point expression.
Expr sinh(Expr x)
Return the hyperbolic sine of a floating-point expression.
Expr atan(Expr x)
Return the arctangent of a floating-point expression.
Expr operator|(Expr x, Expr y)
Return the bitwise or of two expressions (which need not have the same type).
auto operator!=(const Other &a, const GeneratorParam< T > &b) -> decltype(a !=(T) b)
Inequality comparison between between GeneratorParam<T> and any type that supports operator!...
Definition Generator.h:1143
Expr target_bits()
Return the bit width of the Target used during lowering; this can be useful in writing library code w...
Internal::ConstantInterval cast(Type t, const Internal::ConstantInterval &a)
Cast operators for ConstantIntervals.
Expr require(Expr condition, const std::vector< Expr > &values)
Create an Expr that that guarantees a precondition.
Expr is_inf(Expr x)
Returns true if the argument is Inf or -Inf.
Expr is_finite(Expr x)
Returns true if the argument is a finite value (ie, neither NaN nor Inf).
Expr tanh(Expr x)
Return the hyperbolic tangent of a floating-point expression.
Expr likely_if_innermost(Expr e)
Equivalent to likely, but only triggers a loop partitioning if found in an innermost loop.
Expr atanh(Expr x)
Return the hyperbolic arctangent of a floating-point expression.
Expr tan(Expr x)
Return the tangent of a floating-point expression.
Internal::ConstantInterval saturating_cast(Type t, const Internal::ConstantInterval &a)
Expr fast_inverse_sqrt(Expr x)
Fast approximate inverse square root for Float(32).
Expr print(const std::vector< Expr > &values)
Create an Expr that prints out its value whenever it is evaluated.
Expr mul_shift_right(Expr a, Expr b, Expr q)
Compute saturating_narrow(shift_right(widening_mul(a, b), q))
auto operator/(const Other &a, const GeneratorParam< T > &b) -> decltype(a/(T) b)
Division between GeneratorParam<T> and any type that supports operator/ with T.
Definition Generator.h:1052
Expr & operator+=(Expr &a, Expr b)
Modify the first expression to be the sum of two expressions, without changing its type.
Expr abs(Expr a)
Returns the absolute value of a signed integer or floating-point expression.
Expr widen_right_sub(Expr a, Expr b)
Compute a - widen(b).
Expr max(const FuncRef &a, const FuncRef &b)
Definition Func.h:600
Expr floor(Expr x)
Return the greatest whole number less than or equal to a floating-point expression.
Expr div_round_to_zero(Expr x, Expr y)
Divide two integers, rounding towards zero.
Expr widening_sub(Expr a, Expr b)
Compute widen(a) - widen(b).
Expr likely(Expr e)
Expressions tagged with this intrinsic are considered to be part of the steady state of some loop wit...
Expr operator~(Expr x)
Return the bitwise not of an expression.
Expr erf(const Expr &x)
Evaluate the error function erf.
Expr target_has_feature(Target::Feature feat)
Expr operator^(Expr x, Expr y)
Return the bitwise xor of two expressions (which need not have the same type).
unsigned __INT64_TYPE__ uint64_t
signed __INT64_TYPE__ int64_t
signed __INT32_TYPE__ int32_t
unsigned __INT8_TYPE__ uint8_t
unsigned __INT16_TYPE__ uint16_t
unsigned __INT32_TYPE__ uint32_t
signed __INT16_TYPE__ int16_t
signed __INT8_TYPE__ int8_t
A fragment of Halide syntax.
Definition Expr.h:258
A builder to help create Exprs representing halide_buffer_t structs (e.g.
Definition IROperator.h:218
std::vector< Expr > strides
Definition IROperator.h:223
std::vector< Expr > extents
Definition IROperator.h:223
A reference-counted handle to a statement node.
Definition Expr.h:427
static constexpr bool value
Definition IROperator.h:335
Feature
Optional features a target can have.
Definition Target.h:83
Arch
The architecture used by the target.
Definition Target.h:39
OS
The operating system used by the target.
Definition Target.h:23
Types in the halide type system.
Definition Type.h:283
HALIDE_ALWAYS_INLINE bool is_int() const
Is this type a signed integer type?
Definition Type.h:435
HALIDE_ALWAYS_INLINE bool is_float() const
Is this type a floating point type (float or double).
Definition Type.h:423
Class that provides a type that implements half precision floating point (IEEE754 2008 binary16) in s...
Definition Float16.h:17