25 #include "pips_config.h"
58 #include "constants.h"
64 #include "resources.h"
79 #define min(a,b) (((a)<(b))?(a):(b))
80 #define max(a,b) (((a)>(b))?(a):(b))
220 filename =
"inter_trans_stat";
222 mod_name,
".",
prefix,
"_", filename, 0));
239 for (total = 0, i=0; i<4; i++)
244 fprintf(fp,
" %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
297 if (i == dim_array -1)
320 "last upper dimension equal to lower;"
321 " assuming unbounded upper bound\n",
342 #define PHI_FIRST true
343 #define NOT_PHI_FIRST false
350 for (dim=1; dim<=ndim; dim++)
505 pips_debug(7,
"appending declaration system\n");
563 Value offset_1_m_2,
bool backward_p)
568 bool exact_translation_p =
true;
569 bool exact_input_p =
true;
571 debug_on(
"REGION_TRANSLATION_DEBUG_LEVEL");
573 pips_debug(1,
"initial entity: %s, initial function: %s\n",
575 pips_debug(1,
"target entity: %s, target function: %s\n",
580 !((ent_1==ent_2) && (func_1== func_2)));
587 if ((ent_1==ent_2) && (func_1!=func_2))
637 if (!SC_UNDEFINED_P(trans_sc))
643 pips_debug(2,
" translation context system :\n ");
654 if (!exact_translation_p)
713 if (func_1 != func_2)
779 #define Psysteme_domain -1
784 make_translation_context_stack();
789 free_translation_context_stack();
830 int arg_num, n_formals =
gen_length(l_formals);
840 !
ENDP(real_args) && arg_num<=n_formals;
841 real_args =
CDR(real_args), arg_num++)
862 sc_base(sc) = (
Pbase) NULL;
871 translation_context_push(sc);
876 return(translation_context_head());
882 sc_rm(translation_context_head());
883 translation_context_pop();
892 static list l_arguments_to_eliminate =
NIL;
903 l_arguments_to_eliminate =
CONS(
ENTITY, var, l_arguments_to_eliminate);
915 l_arguments_to_eliminate = l_args;
920 l_arguments_to_eliminate =
NIL;
926 return l_arguments_to_eliminate;
935 static Psysteme arrays_same_first_dimensions_sc(
int *p_ind_max);
936 static Psysteme arrays_last_dims_linearization_sc(
int dim_min,
937 bool *p_exact_translation_p);
945 trans_sc = arrays_same_first_dimensions_sc(&i);
949 pips_debug(3,
"same first (%d) dimensions sc:\n", i-1);
956 pips_debug(3,
"all common dimensions have been translated\n");
967 arrays_last_dims_linearization_sc(i, p_exact_translation_p));
984 pips_debug(3,
"the last equations come from the actual array %s.\n",
985 use_ref_p ?
"reference" :
"declaration");
989 for (; i <=
dim_2; i++)
1006 use_ref_p?
"index":
"lower bound");
1007 *p_exact_translation_p =
false;
1029 static void simplify_common_variables(
Pcontrainte c)
1086 static bool arrays_same_ith_dimension_p(
int i)
1088 bool same_dim =
true;
1094 pips_debug(6,
"checking dimension %d.\n", i);
1130 pips_debug(6,
"reference: %ssame lower bound.\n",
1131 same_dim?
"" :
"not ");
1140 static Value dim_cumu_1;
1141 static Value dim_cumu_2;
1186 pips_debug(6,
"offset: %ssame dimension\n", same_dim?
"" :
"not ");
1194 if ( same_dim && !((i==
dim_1) && (i==
dim_2)) )
1225 simplify_common_variables(c);
1246 pips_debug(6,
"size: %ssame %d dimension\n", same_dim?
"":
"not ", i);
1249 pips_debug(6,
"%ssame %d dimension\n", same_dim?
"" :
"not ", i);
1289 static Psysteme arrays_same_first_dimensions_sc(
int *p_ind_max)
1299 same_shape_p =
true;
1300 while ((i <= common_dim) && same_shape_p)
1303 same_shape_p = arrays_same_ith_dimension_p(i);
1377 pips_debug(8,
"dimension %d, translation vector : \n", i);
1386 same_shape_p =
false;
1415 reference_last_indices_offset(
reference ref,
int ind,
bool *p_linear_p)
1425 pips_assert(
"feasible index", 0 < ind && ind <=dim);
1430 pips_debug(8,
"ind = %d, dim = %d\n", ind, dim);
1431 pv_ind_plus_1 = reference_last_indices_offset(
ref, ind + 1, p_linear_p);
1435 pips_debug(8,
"ind = %d, dim = %d", ind, dim);
1465 pips_debug(8,
"lenght of current dimension :\n");
1472 *p_linear_p =
false;
1479 *p_linear_p =
false;
1494 *p_linear_p =
false;
1516 static Pvecteur global_to_last_dims_offset(
int dim_min,
bool *p_linear_p)
1527 pv_offset = global_to_last_dims_offset(dim_min - 1, p_linear_p);
1547 pv_offset =
vect_div(pv_offset, dim_size);
1551 *p_linear_p =
false;
1563 static Pvecteur last_dims_offset(
int dim_min,
bool *p_linear_p)
1574 pv_offset = reference_last_indices_offset(
ref, dim_min, p_linear_p);
1584 if (dim_min >
dim_1) {
1586 *p_linear_p =
false;
1590 pv_offset = global_to_last_dims_offset(dim_min, p_linear_p);
1619 int dim_array,
int dim_min,
int dim_max,
1620 entity (*make_region_entity)(
int))
1627 pips_debug(8,
"dim_min = %d, dim_max = %d, dim_array = %d \n",
1628 dim_min, dim_max, dim_array);
1629 pips_assert(
"dim_max must be less than the dimension of the array\n",
1630 dim_max <= dim_array);
1631 pips_assert(
"dim_min must be less than dim_max\n", dim_min <= dim_max);
1633 if (dim_min < dim_max)
1635 v_dim_min_plus_1 = array_partial_subscript_value(
array, dims, dim_array,
1636 dim_min + 1, dim_max,
1637 make_region_entity);
1647 d = dims[dim_min-1];
1656 if (dim_min < dim_max)
1667 pips_debug(8,
"length of current dimension: \n");
1675 pips_debug(8,
"non linear multiplication\n");
1704 pips_debug(8,
"lower bound not linear : \n");
1733 static Psysteme arrays_last_dims_linearization_sc(
int dim_min,
1734 bool *p_exact_translation_p)
1740 pips_debug(8,
" dim_min = %d, dim_1 = %d, dim_2 = %d \n",
1747 *p_exact_translation_p =
true;
1750 if (dim_min <=
dim_1)
1758 if (*p_exact_translation_p)
1762 if (dim_min <=
dim_2)
1770 if (*p_exact_translation_p)
1772 bool linear_offset_p =
true;
1774 pv_offset = last_dims_offset(dim_min, &linear_offset_p);
1778 *p_exact_translation_p = linear_offset_p;
1783 if (*p_exact_translation_p)
1853 static void region_translate_global_value(
module, reg, val)
1899 pips_debug(8,
"%s is not translatable: store tag %d\n",
1918 pips_debug(8,
"return %s does not need to be translated.\n",
1958 pips_debug(8,
"No equivalent for %s in %s: project %s\n",
1965 "No equivalent location for %s and %s: project %s\n",
1987 pips_debug(8,
"%s has already been translated into %s\n",
2072 static void region_translate_global_values(
module, reg)
2085 for(bv = b; bv != NULL; bv = bv->
succ)
2113 region_translate_global_values(to_func, reg);
2118 pips_debug(8,
"region after translation of globals: \n");
2129 pips_debug(8,
"region before translation: \n");
2159 pips_debug(8,
"region after translation of arguments: \n");
2197 int nb_common_indices,
2203 pips_debug(6,
"beginning with input_ref = %s and address_of_ref = %s, nb_common_indices = %d\n",
2218 int nb_phi_input_ref = (
int)
gen_length(input_remaining_indices);
2220 for(
int i = 0; i<nb_common_indices; i++,
POP(input_remaining_indices));
2222 if(!
ENDP(input_remaining_indices))
2227 if (nb_phi_address_of_ref !=0)
2245 bool feasible =
true;
2248 vect_rm(v_phi_first_non_common);
2277 sc_input =
sc_dup(sc_input);
2278 if (nb_common_indices >0)
2283 bool exact_projection;
2285 *exact_p = *exact_p && exact_projection;
2295 pips_debug(8,
"sc_input after phi_first_non_common variable renaming: \n");
2300 if (nb_phi_address_of_ref != nb_common_indices + 1)
2302 for(i=nb_phi_input_ref; i>(nb_common_indices+1); i--)
2321 pips_debug(8,
"sc_output after variable renaming: \n");
2331 pips_debug(8,
"sc_output after appending sc_input: \n");
2342 v_phi_max_output =
vect_substract(v_phi_max_output, v_rho_max_output);
2347 *exact_p = *exact_p && exact_removal;
2349 *exact_p = *exact_p && exact_removal;
2353 pips_debug(8,
"sc_output after appending removing psi and rho variables: \n");
2360 for(i = nb_phi_address_of_ref +1; i<nb_phi_address_of_ref + nb_phi_input_ref - nb_common_indices; i++)
2362 POP(input_remaining_indices);
2392 sc_output =
sc_dup(sc_input);
2398 if (nb_common_indices >0)
2403 bool exact_projection;
2405 *exact_p = *exact_p && exact_projection;
2411 bool exact_projection;
2413 *exact_p = *exact_p && exact_projection;
2416 for(i=nb_common_indices+2; i<=nb_phi_input_ref; i++)
2426 for(
int i = 1; i<nb_phi_input_ref-nb_common_indices; i++)
2428 POP(input_remaining_indices);
2482 int nb_common_indices,
2488 pips_debug(8,
"nb_common_indices = %d\n", nb_common_indices);
2512 for(
int i = 0; i<nb_common_indices; i++,
POP(input_inds));
2514 int i = nb_phi_value_of+1;
2538 if (nb_common_indices >0)
2543 bool exact_projection;
2545 *exact_p = *exact_p && exact_projection;
2549 if(nb_phi_value_of - nb_common_indices != 0)
2551 if (nb_phi_value_of<nb_common_indices)
2552 for(i= nb_common_indices+1; i<=nb_phi_input; i++)
2556 pips_debug(8,
"case 1: i = %d, nb_phi_value_of+i-nb_common_indices = %d\n",
2557 i, nb_phi_value_of+i-nb_common_indices);
2561 for(i= nb_phi_input; i>nb_common_indices; i--)
2566 pips_debug(8,
"case 2: i = %d, nb_phi_value_of+i-nb_common_indices = %d\n",
2567 i, nb_phi_value_of+i-nb_common_indices);
2581 int nb_common_indices,
2589 address_of_ref, address_of_desc,
2590 nb_common_indices, &output_ref,
2600 int nb_common_indices,
2608 value_of_ref, value_of_desc,
2609 nb_common_indices, &output_ref,
cell make_cell_reference(reference _field_)
action copy_action(action p)
ACTION.
descriptor make_descriptor_convex(Psysteme _field_)
void free_reference(reference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
dimension make_dimension(expression a1, expression a2, list a3)
void free_dimension(dimension p)
reference copy_reference(reference p)
REFERENCE.
struct _newgen_struct_entity_ * entity
static reference ref
Current stmt (an integer)
bool entity_all_locations_p(entity e)
test if an entity is the top of the lattice
entity entity_all_locations()
eturn ANY_MODULE:ANYWHERE (the top of the lattice)
#define int_to_value(i)
end LINEAR_VALUE_IS_INT
#define value_minus(v1, v2)
#define value_notzero_p(val)
#define value_uminus(val)
unary operators on values
void const char const char const int
#define value_notone_p(val)
#define value_zero_p(val)
#define value_eq(v1, v2)
bool operators on values
#define value_division(ref, val)
#define value_product(v, w)
#define value_plus(v1, v2)
binary operators on values
#define value_mod(v1, v2)
void fprint_string_Value(FILE *, char *, Value)
bool base_contains_variable_p(Pbase b, Variable v)
bool base_contains_variable_p(Pbase b, Variable v): returns true if variable v is one of b's elements...
void egalite_debug(Pcontrainte c)
#define CONTRAINTE_NULLE_P(c)
contrainte nulle (non contrainte 0 == 0 ou 0 <= 0)
Pcontrainte contrainte_make(Pvecteur pv)
Pcontrainte contrainte_make(Pvecteur pv): allocation et initialisation d'une contrainte avec un vecte...
Pcontrainte contrainte_free(Pcontrainte c)
Pcontrainte contrainte_free(Pcontrainte c): liberation de l'espace memoire alloue a la contrainte c a...
bool vect_constant_p(Pvecteur)
bool vect_constant_p(Pvecteur v): v contains only a constant term, may be zero
#define region_any_reference(reg)
To be avoided.
#define region_action(reg)
#define debug_region_consistency(reg)
#define region_system_(reg)
#define region_entity(reg)
#define region_system(reg)
#define region_may_p(reg)
#define region_approximation_tag(reg)
#define region
simulation of the type region
#define region_exact_p(reg)
static Psysteme array_translation_sc(bool *p_exact_translation_p)
static struct Common_Dimension_Stat common_dimension_stat
static int mat_dim_stat[8][8]
inputs
void region_translation_init(entity ent_1, reference rf_1, entity ent_2, reference rf_2, Value offset_1_m_2)
static bool dim_2_assumed
static Psysteme entity_assumed_declaration_sc(dimension *dims, int ndim)
static void region_translation_close()
static struct Remaining_Dimension_Stat remaining_dimension_stat
static struct Phi_Elimination_Stat phi_elimination_stat
static int zero_offset_stat
size ratio after normalization
static struct Predicate_Translation predicate_translation_stat
void append_declaration_sc_if_exact_without_constraints(region r)
if we have a region like: <A(PHI)-EXACT-{}> it means that all declared elements are touched,...
static int vect_size_ratio_stat[4]
correspondances between source and target array number of dimensions
static int scalar_to_scalar_stat
number cases in which the offset is nul
static void reg_v_debug(Pvecteur v)
void region_translation_statistics_init(bool stat_p)
initialization and closing
static void region_translation_of_predicate(region reg, entity to_func)
static bool dim_1_assumed
void region_translation_statistics_close(const char *mod_name, const char *prefix)
static bool some_phi_variable(Pcontrainte c)
static int scalar_to_array_stat
static struct Linearization_Stat linearization_stat
static entity array_1
Local variables and functions to avoid multiple computations
static dimension dims_2[NB_MAX_ARRAY_DIM]
static struct Beta_Elimination_Stat beta_elimination_stat
static void reg_sc_debug(Psysteme sc)
static bool dims_array_init(entity array, dimension *dims, int dim_array)
static int array_to_array_stat
static dimension dims_1[NB_MAX_ARRAY_DIM]
#define BACKWARD
Package regions : Be'atrice Creusillet 11/95.
static bool statistics_p
STATISTICS
region region_translation(region reg_1, entity func_1, reference rf_1, entity ent_2, entity func_2, reference rf_2, Value offset_1_m_2, bool backward_p)
region region_translation(region reg1, entity mod1, reference ref1, entity ent2, entity mod2,...
list function_formal_parameters(entity)
void convex_region_descriptor_translation(effect)
entity make_phi_entity(int)
void set_backward_arguments_to_eliminate(entity)
effect make_reference_region(reference, action)
Psysteme cell_reference_sc_exact_projection_along_variable(reference, Psysteme, entity, bool *)
Psysteme get_translation_context_sc(void)
void region_value_substitute(effect, entity, entity)
bool must_regions_p(void)
void convex_cell_reference_with_address_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
void set_translation_context_sc(Psysteme)
void psi_to_phi_region(effect)
list phi_entities_list(int, int)
effect entity_whole_region(entity, action)
void region_sc_append_and_normalize(effect, Psysteme, int)
void convex_cell_reference_with_value_of_cell_reference_translation(reference, descriptor, reference, descriptor, int, reference *, descriptor *, bool *)
void set_forward_arguments_to_eliminate(void)
void convex_cell_with_address_of_cell_translation(cell, descriptor, cell, descriptor, int, cell *, descriptor *, bool *)
void region_remove_beta_variables(effect)
void set_arguments_to_eliminate(list)
void set_interprocedural_translation_context_sc(entity, list)
void reset_arguments_to_eliminate(void)
bool sc_add_phi_equation(Psysteme *, expression, int, bool, bool)
void region_sc_append(effect, Psysteme, bool)
expression make_phi_expression(int)
reference make_regions_psi_reference(entity)
void region_remove_phi_variables(effect)
entity make_beta_entity(int)
utils.c
effect region_dup(effect)
Psysteme entity_declaration_sc(entity)
Psysteme cell_system_sc_append_and_normalize(Psysteme, Psysteme, int)
string region_to_string(effect)
Psysteme cell_reference_system_remove_psi_variables(reference, Psysteme, bool *)
list get_arguments_to_eliminate(void)
void region_exact_projection_along_parameters(effect, list)
void convex_cell_with_value_of_cell_translation(cell, descriptor, cell, descriptor, int, cell *, descriptor *, bool *)
Psysteme cell_reference_system_remove_rho_variables(reference, Psysteme, bool *)
entity make_psi_entity(int)
void region_non_exact_projection_along_parameters(effect, list)
void set_region_interprocedural_translation(void)
void reset_translation_context_sc(void)
entity make_rho_entity(int)
void reset_region_interprocedural_translation(void)
list effect_words_reference(reference)
prettyprint.c
const char * pips_region_user_name(entity)
char * pips_region_user_name(entity ent) output : the name of entity.
reference cell_any_reference(cell)
API for reference.
bool store_effect_p(effect)
bool vect_contains_phi_p(Pvecteur)
bool vect_contains_phi_p(Pvecteur v) input : a vector output : true if v contains a PHI variable,...
#define cell_reference(x)
#define cell_preference(x)
#define descriptor_undefined
#define descriptor_convex(x)
#define cell_preference_p(x)
#define newgen_Psysteme(p)
FILE * safe_fopen(const char *filename, const char *what)
int safe_fclose(FILE *stream, const char *filename)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
bool entities_may_conflict_p(entity e1, entity e2)
Check if two entities may conflict.
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
list gen_last(list l)
Return the last element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
void vect_fprint(FILE *f, Pvecteur v, get_variable_name_t variable_name)
void vect_fprint(FILE * f, Pvecteur v, char * (*variable_name)()): impression d'un vecteur creux v su...
bool vect_equal(Pvecteur v1, Pvecteur v2)
bool vect_equal(Pvecteur v1, Pvecteur v2): test a egalite de deux vecteurs
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define MODULE_SEP_STRING
const char * entity_minimal_name(entity e)
Do preserve scope informations.
void print_arguments(list args)
string concatenate(const char *,...)
Return the concatenation of the given strings.
#define DEFINE_LOCAL_STACK(name, type)
void * gen_find_tabulated(const char *, int)
string db_get_current_workspace_directory(void)
static const char * prefix
#define UNBOUNDED_DIMENSION_NAME
#define NORMALIZE_EXPRESSION(e)
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
bool entity_field_p(entity e)
e is the field of a structure
const char * module_local_name(entity e)
Returns the module local user name.
bool top_level_entity_p(entity e)
Check if the scope of entity e is global.
entity CreateIntrinsic(string name)
this function does not create an intrinsic function because they must all be created beforehand by th...
entity find_ith_formal_parameter(entity the_fnct, int rank)
This function gives back the ith formal parameter, which is found in the declarations of a call or a ...
Pvecteur vect_product(Pvecteur *pv1, Pvecteur *pv2)
returns a Pvecteur equal to (*pv1) * (*pv2) if this product is linear or NULL otherwise.
expression MakeNullaryCall(entity f)
Creates a call expression to a function with zero arguments.
entity expression_variable(expression e)
list module_formal_parameters(entity func)
list module_formal_parameters(entity func) input : an entity representing a function.
bool entity_scalar_p(entity)
The concrete type of e is a scalar type.
expression reference_ith_index(reference, int)
functions for references
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
bool same_scalar_location_p(entity, entity)
FI: transferred from semantics (should be used for effect translation as well)
bool pointer_type_p(type)
Check for scalar pointers.
bool derived_type_p(type)
Returns true if t is of type struct, union or enum.
_int SizeOfElements(basic)
This function returns the length in bytes of the Fortran or C type represented by a basic,...
int NumberOfDimension(entity)
bool entity_integer_scalar_p(entity)
for variables (like I), not constants (like 1)! use integer_constant_p() for constants
#define storage_formal_p(x)
#define normalized_linear_p(x)
#define reference_variable(x)
#define reference_undefined_p(x)
#define dimension_lower(x)
#define entity_storage(x)
#define code_declarations(x)
#define EXPRESSION(x)
EXPRESSION.
#define expression_undefined
#define dimension_upper(x)
#define reference_indices(x)
#define preference_reference(x)
#define variable_dimensions(x)
#define normalized_linear(x)
#define storage_return_p(x)
#define type_variable_p(x)
#define entity_domain
newgen_syntax_domain_defined
#define variable_basic(x)
#define storage_undefined
#define entity_initial(x)
Psysteme sc_variable_rename(Psysteme s, Variable v_old, Variable v_new)
Psysteme sc_variable_rename(Psysteme s, Variable v_old, Variable v_new): reecriture du systeme s remp...
bool sc_rn_p(Psysteme sc)
bool sc_rn_p(Psysteme sc): check if the set associated to sc is the whole space, rn
void sc_creer_base(Psysteme ps)
void sc_creer_base(Psysteme ps): initialisation des parametres dimension et base d'un systeme lineair...
void sc_rm(Psysteme ps)
void sc_rm(Psysteme ps): liberation de l'espace memoire occupe par le systeme de contraintes ps;
void sc_add_egalite(Psysteme p, Pcontrainte e)
void sc_add_egalite(Psysteme p, Pcontrainte e): macro ajoutant une egalite e a un systeme p; la base ...
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
void sc_add_inegalite(Psysteme p, Pcontrainte i)
void sc_add_inegalite(Psysteme p, Pcontrainte i): macro ajoutant une inegalite i a un systeme p; la b...
Psysteme sc_dup(Psysteme ps)
Psysteme sc_dup(Psysteme ps): should becomes a link.
bool eq_redund_with_sc_p(Psysteme sc, Pcontrainte eq)
bool eq_redund_with_sc_p(sc, eq) Psysteme sc; Pcontrainte eq;
bool sc_integer_feasibility_ofl_ctrl(Psysteme sc, int ofl_ctrl, bool ofl_res)
Psysteme sc_constraint_add(Psysteme sc, Pcontrainte c, bool equality)
Psysteme sc_safe_append(Psysteme s1, Psysteme s2)
Psysteme sc_safe_append(Psysteme s1, Psysteme s2) input : output : calcul de l'intersection des polye...
void sc_fprint(FILE *fp, Psysteme ps, get_variable_name_t nom_var)
void sc_fprint(FILE * f, Psysteme ps, char * (*nom_var)()): cette fonction imprime dans le fichier po...
void sc_print(Psysteme ps, get_variable_name_t nom_var)
void sc_print()
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
Psysteme sc_safe_normalize(Psysteme ps)
Psysteme sc_safe_normalize(Psysteme ps) output : ps, normalized.
Pvecteur vect_div(Pvecteur v, Value x)
Pvecteur vect_div(Pvecteur v, Value x): division du vecteur v par le scalaire x, si x est different d...
Pvecteur vect_multiply(Pvecteur v, Value x)
Pvecteur vect_multiply(Pvecteur v, Value x): multiplication du vecteur v par le scalaire x,...
int non_linear_decl_or_offset
struct Scontrainte * succ
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
string words_to_string(cons *lw)
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
#define VECTEUR_NUL
DEFINITION DU VECTEUR NUL.
#define VECTEUR_UNDEFINED
char *(* get_variable_name_t)(Variable)
struct Svecteur * Pvecteur
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
#define BASE_NULLE
MACROS SUR LES BASES.
#define VECTEUR_UNDEFINED_P(v)
Pvecteur vect_make(Pvecteur v, Variable var, Value val,...)
Pvecteur vect_make(v, [var, val,]* 0, val) Pvecteur v; // may be NULL, use assigne anyway Variable va...
Pvecteur vect_dup(Pvecteur v_in)
Pvecteur vect_dup(Pvecteur v_in): duplication du vecteur v_in; allocation de et copie dans v_out;.
Pvecteur vect_new(Variable var, Value coeff)
Pvecteur vect_new(Variable var,Value coeff): allocation d'un vecteur colineaire au vecteur de base va...
void vect_rm(Pvecteur v)
void vect_rm(Pvecteur v): desallocation des couples de v;
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2)
Pvecteur vect_substract(Pvecteur v1, Pvecteur v2): allocation d'un vecteur v dont la valeur est la di...
Pvecteur vect_cl_ofl_ctrl(Pvecteur v, Value lambda, Pvecteur u, int ofl_ctrl)
Pvecteur vect_cl_ofl_ctrl(Pvecteur v, Value lambda, Pvecteur u, int ofl_ctrl): etape d'acculumulation...
void vect_add_elem(Pvecteur *pvect, Variable var, Value val)
void vect_add_elem(Pvecteur * pvect, Variable var, Value val): addition d'un vecteur colineaire au ve...