src/tiramisu_core.cpp
tiramisu::computation::computation(std::string iteration_domain_str, tiramisu::expr e,
                                   bool schedule_this_computation, tiramisu::primitive_t t,
                                   tiramisu::function *fct)
{

    DEBUG_FCT_NAME(3);
    DEBUG_INDENT(4);

    init_computation(iteration_domain_str, fct, e, schedule_this_computation, t);
    is_let = false;

    DEBUG_INDENT(-4);
}
/**
  * Constructor for computations.
  *
  * \p iteration_domain_str is a string that represents the iteration
  * domain of the computation.  The iteration domain should be written
  * in the ISL format (http://isl.gforge.inria.fr/user.html#Sets-and-Relations).
  *
  * The iteration domain of a statement is a set that contains
  * all of the execution instances of the statement (a statement in a
  * loop has an execution instance for each loop iteration in which
  * it executes). Each execution instance of a statement in a loop
  * nest is uniquely represented by an identifier and a tuple of
  * integers  (typically,  the  values  of  the  outer  loop  iterators).
  *
  * For example, the iteration space of the statement S0 in the following
  * loop nest
  * for (i=0; i<2; i++)
  *   for (j=0; j<3; j++)
  *      S0;
  *
  * is {S0(0,0), S0(0,1), S0(0,2), S0(1,0), S0(1,1), S0(1,2)}
  *
  * S0(0,0) is the execution instance of S0 in the iteration (0,0).
  *
  * The previous set of integer tuples can be compactly described
  * by affine constraints as follows
  *
  * {S0(i,j): 0<=i<2 and 0<=j<3}
  *
  * In general, the loop nest
  *
  * for (i=0; i<N; i++)
  *   for (j=0; j<M; j++)
  *      S0;
  *
  * has the following iteration domain
  *
  * {S0(i,j): 0<=i<N and 0<=j<M}
  *
  * This should be read as: the set of points (i,j) such that
  * 0<=i<N and 0<=j<M.
  *
  * \p e is the expression computed by the computation.
  *
  * \p schedule_this_computation should be set to true if the computation
  * is supposed to be schedule and code is supposed to be generated from
  * the computation.  Set it to false if you just want to use the
  * computation to represent a buffer (that is passed as an argument
  * to the function) and you do not intend to generate code for the
  * computation.
  *
  * \p t is the type of the computation, i.e. the type of the expression
  * computed by the computation. Example of types include (p_uint8,
  * p_uint16, p_uint32, ...).
  *
  * \p fct is a pointer to the Tiramisu function where this computation
  * should be added.
  *
  * TODO: copy ISL format for sets.
  */
Constructor for computations.
\p iteration_domain_str is a string that represents the iteration
domain of the computation.  The iteration domain should be written
in the ISL format .

The iteration domain of a statement is a set that contains
all of the execution instances of the statement (a statement in a
loop has an execution instance for each loop iteration in which
it executes). Each execution instance of a statement in a loop
nest is uniquely represented by an identifier and a tuple of
integers  (typically,  the  values  of  the  outer  loop  iterators).

For example, the iteration space of the statement S0 in the following
loop nest
for (i=0; i<2; i++)
for (j=0; j<3; j++)
S0.



S0(0,0) is the execution instance of S0 in the iteration (0,0).

The previous set of integer tuples can be compactly described
by affine constraints as follows



In general, the loop nest



has the following iteration domain



This should be read as: the set of points (i,j) such that
0<=i<N and 0<=j<M.

\p e is the expression computed by the computation.

\p schedule_this_computation should be set to true if the computation
is supposed to be schedule and code is supposed to be generated from
the computation.  Set it to false if you just want to use the
computation to represent a buffer (that is passed as an argument
to the function) and you do not intend to generate code for the
computation.

\p t is the type of the computation, i.e. the type of the expression
computed by the computation.

\p fct is a pointer to the Tiramisu function where this computation
should be added.

copy ISL format for sets.
Constructor for computations . \ p iteration_domain_str is a string that represents the iteration domain of the computation . The iteration domain should be written in the ISL format . The iteration domain of a statement is a set that contains all of the execution instances of the statement ( a statement in a loop has an execution instance for each loop iteration in which it executes ) . Each execution instance of a statement in a loop nest is uniquely represented by an identifier and a tuple of integers ( typically the values of the outer loop iterators ) . For example the iteration space of the statement S0 in the following loop nest for ( i = 0 ; i<2 ; i ++ ) for ( j = 0 ; j<3 ; j ++ ) S0 . S0 ( 0 0 ) is the execution instance of S0 in the iteration ( 0 0 ) . The previous set of integer tuples can be compactly described by affine constraints as follows In general the loop nest has the following iteration domain This should be read as : the set of points ( i j ) such that 0< = i<N and 0< = j<M . \ p e is the expression computed by the computation . \ p schedule_this_computation should be set to true if the computation is supposed to be schedule and code is supposed to be generated from the computation . Set it to false if you just want to use the computation to represent a buffer ( that is passed as an argument to the function ) and you do not intend to generate code for the computation . \ p t is the type of the computation i . e . the type of the expression computed by the computation . \ p fct is a pointer to the Tiramisu function where this computation should be added . copy ISL format for sets .
tiramisu::computation::computation(std::string iteration_domain_str, tiramisu::expr e,
                                   bool schedule_this_computation, tiramisu::primitive_t t,
                                   tiramisu::function *fct)
{
    DEBUG_FCT_NAME(3);
    DEBUG_INDENT(4);
    init_computation(iteration_domain_str, fct, e, schedule_this_computation, t);
    is_let = false;
    DEBUG_INDENT(-4);
}
tiramisu :: computation :: computation ( std :: string iteration_domain_str , tiramisu :: expr e , bool schedule_this_computation , tiramisu :: primitive_t t , tiramisu :: function * fct ) { DEBUG_FCT_NAME ( 3 ) ; DEBUG_INDENT ( 4 ) ; init_computation ( iteration_domain_str , fct , e , schedule_this_computation , t ) ; is_let = false ; DEBUG_INDENT ( -4 ) ; }
Constructor for computations.
Constructor for computations .