include/cloog/constraints.h

   1
   2    /**-------------------------------------------------------------------**
   3     **                               CLooG                               **
   4     **-------------------------------------------------------------------**
   5     **                           constraints.h                           **
   6     **-------------------------------------------------------------------**
   7     **                    First version: april 17th 2005                 **
   8     **-------------------------------------------------------------------**/
   9
  10
  11 /******************************************************************************
  12  *               CLooG : the Chunky Loop Generator (experimental)             *
  13  ******************************************************************************
  14  *                                                                            *
  15  * Copyright (C) 2005 Cedric Bastoul                                          *
  16  *                                                                            *
  17  * This library is free software; you can redistribute it and/or              *
  18  * modify it under the terms of the GNU Lesser General Public                 *
  19  * License as published by the Free Software Foundation; either               *
  20  * version 2.1 of the License, or (at your option) any later version.         *
  21  *                                                                            *
  22  * This library is distributed in the hope that it will be useful,            *
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          *
  25  * Lesser General Public License for more details.                            *
  26  *                                                                            *
  27  * You should have received a copy of the GNU Lesser General Public           *
  28  * License along with this library; if not, write to the Free Software        *
  29  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                         *
  30  * Boston, MA  02110-1301  USA                                                *
  31  *                                                                            *
  32  * CLooG, the Chunky Loop Generator                                           *
  33  * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr                         *
  34  *                                                                            *
  35  ******************************************************************************/
  36
  37
  38 #ifndef CLOOG_CONSTRAINTS_H
  39 #define CLOOG_CONSTRAINTS_H
  40
  41 #if defined(CLOOG_POLYLIB)
  42 #include <cloog/polylib/matrix.h>
  43 #elif defined(CLOOG_ISL)
  44 #include <cloog/isl/matrix.h>
  45 #else
  46 struct cloogconstraintset;
  47 typedef struct cloogconstraintset CloogConstraintSet;
  48 struct cloogequalities;
  49 typedef struct cloogequalities CloogEqualities;
  50 #endif
  51
  52 #if defined(__cplusplus)
  53 extern "C"
  54   {
  55 #endif
  56
  57 /******************************************************************************
  58  *                        Equalities spreading functions                      *
  59  ******************************************************************************/
  60 CloogEqualities *cloog_equal_alloc(int n, int nb_levels,
  61                         int nb_parameters);
  62 void             cloog_equal_free(CloogEqualities *equal);
  63 int              cloog_equal_count(CloogEqualities *equal);
  64 int              cloog_equal_type(CloogEqualities *equal, int level);
  65 void             cloog_equal_del(CloogEqualities *equal, int level);
  66 int              cloog_equal_total_dimension(CloogEqualities *equal);
  67
  68 /******************************************************************************
  69  *                            Processing functions                            *
  70  ******************************************************************************/
  71 void          cloog_constraint_set_normalize(CloogConstraintSet *, int);
  72 void          cloog_constraint_set_free(CloogConstraintSet *);
  73 int           cloog_constraint_set_contains_level(CloogConstraintSet *constraints,
  74                         int level, int nb_parameters);
  75 int           cloog_constraint_set_total_dimension(CloogConstraintSet *constraints);
  76 int           cloog_constraint_set_n_iterators(CloogConstraintSet *constraints,
  77                         int nb_parameters);
  78 CloogConstraintSet *cloog_constraint_set_copy(CloogConstraintSet *);
  79 CloogConstraintSet *cloog_constraint_set_simplify(CloogConstraintSet *, CloogEqualities *, int, int);
  80
  81 #if defined(CLOOG_POLYLIB) || defined(CLOOG_ISL)
  82
  83 CloogConstraintSet *cloog_constraint_set_for_reduction(CloogConstraint upper,
  84                CloogConstraint lower);
  85 CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
  86         int level, CloogEqualities *equal, int nb_par, cloog_int_t *bound);
  87 CloogConstraint cloog_constraint_first(CloogConstraintSet *constraints);
  88 int             cloog_constraint_is_valid(CloogConstraint constraint);
  89 CloogConstraint cloog_constraint_next(CloogConstraint constraint);
  90 CloogConstraint cloog_constraint_copy(CloogConstraint constraint);
  91 void            cloog_constraint_release(CloogConstraint constraint);
  92 CloogConstraint cloog_constraint_invalid(void);
  93 int             cloog_constraint_total_dimension(CloogConstraint constraint);
  94
  95 CloogConstraint cloog_equal_constraint(CloogEqualities *equal, int j);
  96 void            cloog_equal_add(CloogEqualities *equal,
  97                                   CloogConstraintSet *constraints,
  98                                   int level, CloogConstraint line, int nb_par);
  99
 100 CloogConstraint cloog_constraint_set_defining_equality(
 101                         CloogConstraintSet *constraints, int level);
 102 CloogConstraint cloog_constraint_set_defining_inequalities(
 103                         CloogConstraintSet *constraints,
 104                         int level, CloogConstraint *lower, int nb_parameters);
 105 int           cloog_constraint_involves(CloogConstraint constraint, int v);
 106 int           cloog_constraint_is_lower_bound(CloogConstraint constraint, int v);
 107 int           cloog_constraint_is_upper_bound(CloogConstraint constraint, int v);
 108 int           cloog_constraint_is_equality(CloogConstraint constraint);
 109 void          cloog_constraint_constant_get(CloogConstraint constraint,
 110                         cloog_int_t *val);
 111 void          cloog_constraint_coefficient_get(CloogConstraint constraint,
 112                         int var, cloog_int_t *val);
 113 void          cloog_constraint_coefficient_set(CloogConstraint constraint,
 114                         int var, cloog_int_t val);
 115 void          cloog_constraint_clear(CloogConstraint constraint);
 116 void          cloog_constraint_copy_coefficients(CloogConstraint constraint,
 117                         cloog_int_t *dst);
 118
 119 struct clast_expr *cloog_constraint_variable_expr(CloogConstraint constraint,
 120                         int level, CloogNames *names);
 121
 122 #endif
 123
 124 #if defined(__cplusplus)
 125   }
 126 #endif
 127 #endif /* define _H */