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