Loading...
Searching...
No Matches
InlineReductions.h
Go to the documentation of this file.
#ifndef HALIDE_INLINE_REDUCTIONS_H
#define HALIDE_INLINE_REDUCTIONS_H
#include <string>
#include "Expr.h"
#include "RDom.h"
#include "Tuple.h"
/** \file
* Defines some inline reductions: sum, product, minimum, maximum.
*/
namespace Halide {
class Func;
/** An inline reduction. This is suitable for convolution-type
* operations - the reduction will be computed in the innermost loop
* that it is used in. The argument may contain free or implicit
* variables, and must refer to some reduction domain. The free
* variables are still free in the return value, but the reduction
* domain is captured - the result expression does not refer to a
* reduction domain and can be used in a pure function definition.
*
* An example using \ref sum :
*
\code
Func f, g;
Var x;
RDom r(0, 10);
f(x) = x*x;
g(x) = sum(f(x + r));
\endcode
*
* Here g computes some blur of x, but g is still a pure function. The
* sum is being computed by an anonymous reduction function that is
* scheduled innermost within g.
*/
//@{
Expr sum(Expr, const std::string &s = "sum");
Expr saturating_sum(Expr, const std::string &s = "saturating_sum");
Expr product(Expr, const std::string &s = "product");
Expr maximum(Expr, const std::string &s = "maximum");
Expr minimum(Expr, const std::string &s = "minimum");
//@}
/** Variants of the inline reduction in which the RDom is stated
* explicitly. The expression can refer to multiple RDoms, and only
* the inner one is captured by the reduction. This allows you to
* write expressions like:
\code
RDom r1(0, 10), r2(0, 10), r3(0, 10);
Expr e = minimum(r1, product(r2, sum(r3, r1 + r2 + r3)));
\endcode
*/
// @{
Expr sum(const RDom &, Expr, const std::string &s = "sum");
Expr saturating_sum(const RDom &r, Expr e, const std::string &s = "saturating_sum");
Expr product(const RDom &, Expr, const std::string &s = "product");
Expr maximum(const RDom &, Expr, const std::string &s = "maximum");
Expr minimum(const RDom &, Expr, const std::string &s = "minimum");
// @}
/** Returns an Expr or Tuple representing the coordinates of the point
* in the RDom which minimizes or maximizes the expression. The
* expression must refer to some RDom. Also returns the extreme value
* of the expression as the last element of the tuple. */
// @{
Tuple argmax(Expr, const std::string &s = "argmax");
Tuple argmin(Expr, const std::string &s = "argmin");
Tuple argmax(const RDom &, Expr, const std::string &s = "argmax");
Tuple argmin(const RDom &, Expr, const std::string &s = "argmin");
// @}
/** Inline reductions create an anonymous helper Func to do the
* work. The variants below instead take a named Func object to use,
* so that it is no longer anonymous and can be scheduled
* (e.g. unrolled across the reduction domain). The Func passed must
* not have any existing definition. */
//@{
Expr sum(Expr, const Func &);
Expr saturating_sum(Expr, const Func &);
Expr product(Expr, const Func &);
Expr maximum(Expr, const Func &);
Expr minimum(Expr, const Func &);
Expr sum(const RDom &, Expr, const Func &);
Expr saturating_sum(const RDom &r, Expr e, const Func &);
Expr product(const RDom &, Expr, const Func &);
Expr maximum(const RDom &, Expr, const Func &);
Expr minimum(const RDom &, Expr, const Func &);
Tuple argmax(Expr, const Func &);
Tuple argmin(Expr, const Func &);
Tuple argmax(const RDom &, Expr, const Func &);
Tuple argmin(const RDom &, Expr, const Func &);
//@}
} // namespace Halide
#endif
Expr.h
Base classes for Halide expressions (Halide::Expr) and statements (Halide::Internal::Stmt).
RDom.h
Defines the front-end syntax for reduction domains and reduction variables.
Tuple.h
Defines Tuple - the front-end handle on small arrays of expressions.
Halide::Func
A halide function.
Definition Func.h:706
Halide::RDom
A multi-dimensional domain over which to iterate.
Definition RDom.h:193
Halide::Tuple
Create a small array of Exprs for defining and calling functions with multiple outputs.
Definition Tuple.h:18
Halide
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
Definition AbstractGenerator.h:19
Halide::argmax
Tuple argmax(Expr, const std::string &s="argmax")
Returns an Expr or Tuple representing the coordinates of the point in the RDom which minimizes or max...
Halide::argmin
Tuple argmin(Expr, const std::string &s="argmin")
Halide::maximum
Expr maximum(Expr, const std::string &s="maximum")
Halide::sum
Expr sum(Expr, const std::string &s="sum")
An inline reduction.
Halide::product
Expr product(Expr, const std::string &s="product")
Halide::saturating_sum
Expr saturating_sum(Expr, const std::string &s="saturating_sum")
Halide::minimum
Expr minimum(Expr, const std::string &s="minimum")
Halide::Expr
A fragment of Halide syntax.
Definition Expr.h:258