6 #ifndef sc_header_included
7 #define sc_header_included
157 #define get_sc_debug_level() sc_debug_level
158 #define ifscdebug(l) if (get_sc_debug_level()>=l)
162 #define sc_nbre_egalites(psc) ((psc)->nb_eq)
163 #define sc_nbre_inegalites(psc) ((psc)->nb_ineq)
164 #define sc_egalites(psc) ((psc)->egalites)
165 #define sc_inegalites(psc) ((psc)->inegalites)
166 #define sc_base(psc) ((psc)->base)
167 #define sc_dimension(psc) ((psc)->dimension)
175 extern void syst_restart(FILE * input_file );
179 #define sc_add_eg(p,c) sc_add_egalite(p, c)
180 #define sc_add_ineg(p,c) sc_add_inegalite(p, c)
187 #define SC_EMPTY ((Psysteme) NULL)
188 #define SC_EMPTY_P(sc) ((sc)==SC_EMPTY)
197 #define SC_RN ((Psysteme) NULL)
198 #define SC_RN_P(sc) ((sc)==(Psysteme) NULL)
202 #define SC_UNDEFINED ((Psysteme) NULL)
203 #define SC_UNDEFINED_P(sc) ((sc)==(Psysteme) NULL)
208 #define NB_INEQ_MAX1 100
213 #define NB_INEQ_MAX2 50
218 #define sc_faisabilite(sc) sc_rational_feasibility_ofl_ctrl((sc), NO_OFL_CTRL,true)
219 #define sc_faisabilite_ofl(sc) \
220 sc_rational_feasibility_ofl_ctrl((sc), FWD_OFL_CTRL, true)
221 #define sc_feasible_ofl(sc, b) sc_rational_feasibility_ofl_ctrl((sc), OFL_CTRL, (b))
222 #define sc_elim_redond(ps) sc_elim_redund((ps))
223 #define sc_triang_elim_redond(x,y) sc_triang_elim_redund(x,y)
224 #define sc_rm_empty_constraints( ps,b) sc_elim_empty_constraints((ps),(b))
225 #define sc_kill_db_eg( ps) sc_elim_db_constraints((ps))
226 #define sc_safe_kill_db_eg( ps) sc_safe_elim_db_constraints((ps))
227 #define non_redundent_subsystem( s1, s2) extract_nredund_subsystem((s1), (s2))
228 #define sc_nredund_ofl( psc) build_sc_nredund_2pass_ofl_ctrl((psc),FWD_OFL_CTRL)
229 #define sc_nredund_optim( psc) build_sc_nredund_2pass((psc))
230 #define sc_nredund( psc) build_sc_nredund_2pass((psc))
231 #define sc_projection_on_list_of_variables(sc,ib,pv) \
232 sc_projection_on_variables((sc),(ib),(pv))
233 #define combiner(sc, v) \
234 sc_fourier_motzkin_variable_elimination_ofl_ctrl((sc),(v),false,false,NO_OFL_CTRL)
235 #define combiner_ofl(sc, v) \
236 sc_fourier_motzkin_variable_elimination_ofl_ctrl((sc),(v),false,false,FWD_OFL_CTRL)
237 #define exact_combiner_ofl(sc, v, b) \
238 sc_fourier_motzkin_variable_elimination_ofl_ctrl((sc),(v),true, (b), FWD_OFL_CTRL)
239 #define eq_v_min_coeff(c, v, cf) contrainte_var_min_coeff((c), (v), (cf), false)
240 #define sc_projection_ofl_with_eq(sc, eq, v) \
241 sc_variable_substitution_with_eq_ofl_ctrl((sc), (eq), (v), FWD_OFL_CTRL)
242 #define cond_suff_comb_integer(sc,pos,neg, v) \
243 cond_suff_comb_integer_ofl_ctrl((sc),(pos),(neg), (v), NO_OFL_CTRL)
244 #define cond_suff_comb_integer_ofl(sc,pos,neg, v) \
245 cond_suff_comb_integer_ofl_ctrl((sc),(pos),(neg), (v), FWD_OFL_CTRL)
246 #define sc_projection_int_along_vecteur(fsc,sc,ib,pv,ti,dim,n) \
247 sc_integer_projection_along_variables((fsc),(sc),(ib),(pv),(ti),(dim),(n))
248 #define integer_projection(sci,sc,v) \
249 sc_integer_projection_along_variable((sci),(sc),(v))
251 typedef int two_int_info[2];
252 typedef two_int_info *two_int_infop;
254 typedef int (* constraint_cmp_func_t)
278 extern void sc_projection_along_variable_ofl_ctrl(
Psysteme volatile *,
Variable ,
int );
279 extern void sc_and_base_projection_along_variable_ofl_ctrl(
Psysteme volatile *,
Variable ,
int );
280 extern void sc_projection_along_variables_ofl_ctrl(
Psysteme *,
Pvecteur ,
int );
281 extern void sc_projection_along_variables_with_test_ofl_ctrl(
Psysteme *,
Pvecteur ,
bool *,
int );
284 extern bool sc_fourier_motzkin_variable_elimination_ofl_ctrl(
Psysteme ,
Variable ,
bool ,
bool *,
int );
298 extern void sc_project_very_simple_equalities(
Psysteme );
299 extern void sc_projection_along_variable_ofl_ctrl_timeout_ctrl(
Psysteme volatile *,
Variable ,
int );
440 extern void sc_error(
char *,
char *, ...);
500 extern short int cote;
505 extern int syst_char;
506 extern int syst_nerrs;
509 extern int syst_leng;
511 extern FILE *syst_out;
512 extern int syst_lineno;
513 extern int syst__flex_debug;
514 extern char *syst_text;
516 extern void syst_restart(FILE *);
517 extern void syst_pop_buffer_state(
void);
518 extern int syst_get_lineno(
void);
519 extern FILE *syst_get_in(
void);
520 extern FILE *syst_get_out(
void);
521 extern int syst_get_leng(
void);
522 extern char *syst_get_text(
void);
523 extern void syst_set_lineno(
int );
524 extern void syst_set_in(FILE *);
525 extern void syst_set_out(FILE *);
526 extern int syst_get_debug(
void);
527 extern void syst_set_debug(
int );
528 extern int syst_lex_destroy(
void);
530 extern void *syst_realloc(
void *,
yy_size_t );
531 extern void syst_free(
void *);
533 extern int syst_input(
void);
534 extern int syst_wrap(
void);
void const char const char const int
bool sc_janus_feasibility_fallback(Psysteme sc __attribute__((unused)))
Fallback function to compute feasibility with Janus, used when no custom function is set.
bool sc_janus_feasibility(Psysteme sc)
Compute feasibility, using custom Janus function if set, fallback function otherwise.
void set_sc_janus_feasibility(bool(*sc_janus_feasibility_fct)(Psysteme))
Set custom Janus feasibility function.
void sc_base_add_variable(Psysteme sc, Variable var)
void sc_base_remove_variable(Psysteme sc, Variable v)
void norm_syst(Psysteme sc)
norm_syst(Psysteme): division des contraintes, egalites ou inegalites, par le PGCD des coefficients d...
bool sc_consistent_p(Psysteme sc)
bool sc_consistent_p(Psysteme sc): check that sc is well defined, that the numbers of equalities and ...
Psysteme sc_rename_variables(Psysteme s, bool(*renamed_p)(), Variable(*new_variable)())
Psysteme sc_rename_variables(s, renamed_p, new_variable) Psysteme s; bool (*renamed_p)(Variable); Var...
Psysteme sc_translate(Psysteme s, Pbase b, char *(*variable_name)())
Psysteme sc_translate(Psysteme s, Pbase b, char * (*variable_name)()): reecriture du systeme s dans l...
Psysteme sc_make(Pcontrainte leg, Pcontrainte lineg)
Psysteme sc_make(Pcontrainte leg, Pcontrainte lineg): allocation et initialisation d'un systeme d'equ...
void sc_separate_on_vars(Psysteme s, Pbase b, Psysteme *pwith, Psysteme *pwithout)
Psysteme sc_variables_rename(Psysteme s, Pvecteur pv_old, Pvecteur pv_new, get_variable_name_t variable_name)
Psysteme sc_variables_rename(Psysteme s, Pvecteur pv_old, Pvecteur pv_new): reecriture du systeme s r...
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_weak_consistent_p(Psysteme sc)
check that sc is well defined, that the numbers of equalities and inequalities are consistent with th...
Psysteme sc_substitute_dimension(Psysteme s, Variable i, Pvecteur v)
Psysteme sc_substitute_dimension(Psysteme s, Variable i, Pvecteur v): The ith dimension of all constr...
struct Ssysteme * Psysteme
bool sc_rn_p(Psysteme sc)
bool sc_rn_p(Psysteme sc): check if the set associated to sc is the whole space, rn
Psysteme sc_empty(Pbase b)
Psysteme sc_empty(Pbase b): build a Psysteme with one unfeasible constraint to define the empty subsp...
Psysteme sc_rn(Pbase b)
Psysteme sc_rn(Pbase b): build a Psysteme without constraints to define R^n, where n is b's dimension...
void sc_creer_base(Psysteme ps)
void sc_creer_base(Psysteme ps): initialisation des parametres dimension et base d'un systeme lineair...
void sc_fix(Psysteme s)
fix system s for coherency of the base and number of things.
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 ...
void sc_add_inegalites(Psysteme p, Pcontrainte i)
Pbase sc_to_minimal_basis(Psysteme ps)
creation d'une base contenant toutes les variables apparaissant avec des coefficients non-nuls dans l...
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
Psysteme sc_init_with_sc(Psysteme sc)
This function returns a new empty system which has been initialized with the same dimension and base ...
bool sc_empty_p(Psysteme sc)
bool sc_empty_p(Psysteme sc): check if the set associated to sc is the constant sc_empty or not.
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.
Pbase sc_base_dup(int nbv, Pbase b)
Variable * sc_base_dup(int nbv, Variable * b): duplication de la table des variables base,...
void sc_add_egalites(Psysteme p, Pcontrainte i)
Psysteme sc_copy(Psysteme ps)
Psysteme sc_copy(Psysteme ps): duplication d'un systeme (allocation et copie complete des champs sans...
bool sc_internal_p(Psysteme ps, Pvecteur v)
Check if the integer point defined by vector v is stricly inside the set defined by the constraints o...
bool sc_belongs_p(Psysteme ps, Pvecteur v)
package sc
void build_sc_nredund_1pass(Psysteme volatile *ps)
Computation of a new system sc from the system ps, where each constraint of the system ps is added to...
void build_sc_nredund_2pass_ofl_ctrl(Psysteme volatile *psc, int ofl_ctrl)
bool ineq_redund_with_sc_p(Psysteme sc, Pcontrainte ineq)
This function returns true if the inequation ineq is redundant for the system ps and false otherwise.
void sc_safe_build_sc_nredund_2pass(Psysteme volatile *ps)
void build_sc_nredund_2pass(Psysteme volatile *psc)
void build_sc_nredund_2pass Psysteme *psc;
Psysteme build_integer_sc_nredund(volatile Psysteme ps, Pbase index_base, int tab_info[][4], int loop_level, int dim_h __attribute__((unused)), int n __attribute__((unused)))
Computation of a new system sc from the system ps, where each constraint of the system ps is added to...
bool bound_redund_with_sc_p(Psysteme sc, Pcontrainte ineq1, Pcontrainte ineq2, Variable var)
This function returns true if the constraint C (resulting of the combination of the two constraints i...
Psysteme extract_nredund_subsystem(Psysteme s1, Psysteme s2)
Psysteme extract_nredund_subsystem(s1, s2) Psysteme s1, s2;.
bool eq_redund_with_sc_p(Psysteme sc, Pcontrainte eq)
bool eq_redund_with_sc_p(sc, eq) Psysteme sc; Pcontrainte eq;
void sc_safe_build_sc_nredund_1pass(Psysteme volatile *ps)
void build_sc_nredund_1pass_ofl_ctrl(Psysteme volatile *psc, int ofl_ctrl)
Psysteme build_sc_nredund_1pass_ofl_ctrl(Psysteme ps, int ofl_ctrl) input : a system in which redunda...
int sc_switch_heuristic_flag
char * default_variable_to_string(Variable v)
void set_sc_debug_level(int l)
SET FUNCTIONS.
void sc_variable_name_pop(void)
void sc_variable_name_push(char *(*fun)(Variable))
void initialize_sc(char *(*var_to_string)(Variable))
Psysteme sc_inequations_elim_redund(Psysteme ps)
package sc
Psysteme sc_elim_redund(Psysteme ps)
Psysteme sc_elim_redund(Psysteme ps): elimination des contraintes lineaires redondantes dans le syste...
Psysteme sc_safe_elim_redund(Psysteme ps)
Same as above, but the basis is preserved and sc_empty is returned is the system is not feasible.
bool sc_elim_simple_redund_with_ineq(Psysteme ps, Pcontrainte ineg)
bool sc_elim_simple_redund_with_ineq(Psysteme ps, Pcontrainte ineg): elimination des contraintes redo...
Psysteme sc_elim_double_constraints(Psysteme ps)
Psysteme sc_elim_double_constraints(Psysteme ps): elimination des egalites et des inegalites identiqu...
void sc_elim_empty_constraints(Psysteme ps, bool process_equalities)
void sc_elim_empty_constraints(Psysteme ps, bool process_equalities): elimination des "fausses" contr...
Psysteme sc_safe_elim_db_constraints(Psysteme ps)
The returned value must be used because they argument is freed when the system is not feasible.
bool sc_elim_simple_redund_with_eq(Psysteme ps, Pcontrainte eg)
package sc
Psysteme sc_elim_db_constraints(Psysteme ps)
Psysteme sc_elim_db_constraints(Psysteme ps): elimination des egalites et des inegalites identiques o...
int sc_check_inequality_redundancy(Pcontrainte ineq, Psysteme ps)
int sc_check_inequality_redundancy(Pcontrainte ineq, Psysteme ps) Check if an inequality ineq,...
void sc_error(char *name, char *fmt,...)
package sc
void sc_force_variable_to_zero(Psysteme ps, Variable var)
void sc_force_variable_to_zero(Psysteme ps, Variable var): force la variable var a prendre la valeur ...
bool sc_minmax_of_variable(Psysteme ps, Variable var, Value *pmin, Value *pmax)
void sc_minmax_of_variable(Psysteme ps, Variable var, Value *pmin, *pmax): examine un systeme pour tr...
bool sc_value_of_variable(Psysteme ps, Variable var, Value *pval)
bool sc_value_for_variable(Psysteme ps, Variable var, Value *pval): examine les egalites du systeme p...
void sc_minmax_of_variables(Psysteme ps1, Psysteme ps2, Pbase b)
This function uses sc_minmax_of_variable to compute the min and max of each variable belonging to bas...
bool sc_minmax_of_variable2(volatile Psysteme ps, Variable var, Value *pmin, Value *pmax)
void sc_minmax_of_variable2(Psysteme ps, Variable var, Value *pmin, *pmax): examine un systeme pour t...
bool sc_fourier_motzkin_feasibility_ofl_ctrl(Psysteme s, bool integer_p, int ofl_ctrl)
bool sc_fourier_motzkin_faisabilite_ofl(Psysteme s): test de faisabilite d'un systeme de contraintes ...
bool efficient_sc_check_inequality_feasibility(Pvecteur v, Psysteme prec)
void decision_data(Pcontrainte c, int volatile *pc, int volatile *pv, Value *magnitude, int weight)
just a test to improve the Simplex/FM decision.
bool sc_rational_feasibility_ofl_ctrl(Psysteme sc, int ofl_ctrl, bool ofl_res)
bool sc_integer_feasibility_ofl_ctrl(Psysteme sc, int ofl_ctrl, bool ofl_res)
bool sc_fourier_motzkin_feasibility_ofl_ctrl_timeout_ctrl(Psysteme sc, bool int_p, int ofl_ctrl)
bool sc_simplexe_feasibility_ofl_ctrl_timeout_ctrl(Psysteme sc, bool project_eq_p, bool int_p, int ofl_ctrl)
bool sc_feasibility_ofl_ctrl(Psysteme sc, bool integer_p, volatile int ofl_ctrl, volatile bool ofl_res)
return true is the system is feasible
bool sc_janus_feasibility_ofl_ctrl_timeout_ctrl(Psysteme sc, bool ofl_ctrl)
bool syst_syntax_error
detection des erreurs de syntaxe par sc_gram.y
int syst_error(char *)
First part of user prologue.
Value b1
booleen indiquant quel membre est en cours d'analyse
short int operat
pointeur sur le membre courant
short int cote
indique le sens de l'inegalite sens = -1 ==> l'operateur est soit > ,soit >=, sens = 1 ==> l'operateu...
int sens
facteur multiplicatif suivant qu'on analyse un terme
Pcontrainte eq
element du vecteur colonne du systeme donne par l'analyse
Psysteme ps_yacc
package sc
Pvecteur cp
pointeur sur l'egalite ou l'inegalite courante
Psysteme sc_inequality_add(Psysteme sc, Pcontrainte c)
Psysteme sc_equation_add(Psysteme sc, Pcontrainte c)
The basis of the constraint system is updated.
void insert_ineq_end_sc(Psysteme sc, Pcontrainte ineq)
This function inserts one constraint ineq at the end of the system of inequalities of sc.
void insert_ineq_begin_sc(Psysteme sc, Pcontrainte ineq)
This function inserts the constraint ineq at the beginning of the system of inequalities of sc.
void insert_2ineq_end_sc(Psysteme sc, Pcontrainte ineq)
This function inserts two constraints ineq and ineq->succ at the end of the system of inequalities of...
Psysteme sc_constraint_add(Psysteme sc, Pcontrainte c, bool equality)
void sc_integer_projection_information(Psysteme sc, Pbase index_base, int sc_info[][4], int dim_h, int n)
This function gives information about the variables and the constraints of the system.
bool var_with_unity_coeff_p(Psysteme sc, Variable var)
This function returns true: if all positive OR all negative coefficients of the variable var in the s...
void constraint_integer_combination(Pbase index_base, Pcontrainte ineq1, Pcontrainte ineq2, int rank, Variable *right_var, int *right_rank, Value *right_coeff, Variable *left_var, int *left_rank, Value *left_coeff)
This function computes the coefficients of the constraint resulting from the elimination of the varia...
Psysteme sc_append(Psysteme s1, Psysteme s2)
Psysteme sc_append(Psysteme s1, Psysteme s2): calcul de l'intersection des polyedres definis par s1 e...
bool sc_intersection_empty_p_ofl(Psysteme ps1, Psysteme ps2)
bool sc_intersection_empty_p_ofl(ps1, ps2) input : two polyhedra output : true if their intersection ...
Psysteme sc_safe_intersection(Psysteme s1, Psysteme s2, Psysteme s3)
Psysteme sc_safe_intersection(Psysteme s1, Psysteme s2, Psysteme s3) input : output : calcul d'un sys...
Psysteme sc_safe_append(Psysteme s1, Psysteme s2)
Psysteme sc_safe_append(Psysteme s1, Psysteme s2) input : output : calcul de l'intersection des polye...
Psysteme extract_common_syst(Psysteme s1, Psysteme s2)
returns the common subsystem if appropriate...
Psysteme sc_fusion(Psysteme s1, Psysteme s2)
package sc
Psysteme sc_intersection(Psysteme s1, Psysteme s2, Psysteme s3)
Psysteme sc_intersection(Psysteme s1, Psysteme s2, Psysteme s3): calcul d'un systeme de contraintes s...
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()
void sc_default_dump_to_files(Psysteme sc, int sc_nb, char *directory_name)
void sc_default_dump_to_files(Psysteme sc, sc_nb,directory_name):
Psysteme * sc_read(char *nomfic)
Psysteme * sc_read(char * nomfic): construit un systeme d'inegalites lineaires a partir d'une represe...
void sc_fprint_for_sc_fscan(FILE *f, Psysteme sc, char *(*nom_var)(Variable))
void sc_fprint_for_sc_fscan(FILE *f, Psysteme sc, char * (*nom_var)(Variable))
FILE * syst_in
fichier lu par sc_lex.l
bool sc_fscan(FILE *f, Psysteme *ps)
bool sc_fscan(FILE * f, Psysteme * ps): construit un systeme d'inegalites et d'egalites lineaires a p...
void sc_dump(Psysteme sc)
void sc_dump(Psysteme sc): dump to stderr
void sc_default_dump(Psysteme sc)
void sc_default_dump(Psysteme sc): dump to stderr
char * sc_internal_symbol_table(char *)
bool sc_inequalities_constrain_variable_p(Psysteme sc, Variable var)
Psysteme sc_restricted_to_variables_transitive_closure(Psysteme sc, Pbase variables)
for an improved dependence test (Beatrice Creusillet)
bool sc_constrains_variable_p(Psysteme sc, Variable var, bool is_equations_p)
Does "var" appears with a non-zero coefficient in any equation or inequality of constraint system "sc...
bool sc_equations_constrain_variable_p(Psysteme sc, Variable var)
void sc_set_row_echelon_redundancy(bool b __attribute__((unused)))
void algorithm_tiling(Psysteme syst, Pbase outer, Pbase inner, Psysteme *pcondition, Psysteme *ptile_enum, Psysteme *piter_enum)
Psysteme new_loop_bound(Psysteme scn, Pbase base_index)
Psysteme new_loop_bound(Psysteme scn, Pbase base_index) computation of the new iteration space (given...
void algorithm_row_echelon_generic(Psysteme scn, Pbase base_index, Psysteme *pcondition, Psysteme *penumeration, bool redundancy)
each variable should be at least within one <= and one >=; scn IS NOT modified.
Psysteme get_other_constraints(Psysteme *psyst, Pbase vars)
Psysteme get_other_constraints(psyst, vars) Psysteme *psyst; Pbase vars;.
void algorithm_row_echelon(Psysteme scn, Pbase base_index, Psysteme *pcondition, Psysteme *penumeration)
see comments above.
Psysteme sc_add_normalize_ineq(Psysteme ps, Pcontrainte ineq)
Psysteme sc_normalize2(volatile Psysteme ps)
Psysteme sc_normalize2(Psysteme ps): normalisation d'un systeme d'equation et d'inequations lineaires...
Psysteme sc_strong_normalize3(Psysteme ps)
Psysteme sc_strong_normalize5(Psysteme ps, char *(*variable_name)(Variable))
Psysteme sc_strong_normalize_and_check_feasibility2(volatile Psysteme ps, Psysteme(*check_feasibility)(Psysteme), char *(*variable_name)(Variable), int level)
Psysteme sc_strong_normalize_and_check_feasibility2 (Psysteme ps, Psysteme (*check_feasibility)(Psyst...
Psysteme sc_strong_normalize4(Psysteme ps, char *(*variable_name)(Variable))
Psysteme sc_strong_normalize4(Psysteme ps, char * (*variable_name)(Variable))
Pcontrainte find_intermediate_constraints_recursively(Pvecteur v, Variable x, Variable y, Value lmpx, Value lmpy, Value rmpx, Value rmpy)
Find a set ineq of 2-D constraints equivalent to 2-D constraint v==ax+by+c over the interval [lmpx,...
Psysteme sc_strong_normalize_and_check_feasibility(volatile Psysteme ps, Psysteme(*check_feasibility)(Psysteme))
void sc_gcd_normalize(Psysteme ps)
sc_gcd_normalize(ps)
Psysteme sc_strong_normalize2(volatile Psysteme ps)
Psysteme sc_strong_normalize2(Psysteme ps)
Psysteme sc_add_normalize_eq(Psysteme ps, Pcontrainte eq)
Psysteme sc_safe_normalize(Psysteme ps)
Psysteme sc_safe_normalize(Psysteme ps) output : ps, normalized.
Psysteme sc_normalize(Psysteme ps)
Psysteme sc_normalize(Psysteme ps): normalisation d'un systeme d'equation et d'inequations lineaires ...
Psysteme sc_bounded_normalization(Psysteme ps)
Eliminate trivially redundant integer constraint using a O(n x d^2) algorithm, where n is the number ...
Psysteme sc_strong_normalize(Psysteme ps)
Psysteme sc_strong_normalize(Psysteme ps)
Pcontrainte find_intermediate_constraints(Pvecteur v, Variable x, Variable y, Value lmpx, Value lmpy, Value rmpx, Value rmpy)
Find a set ineq of 2-D constraints equivalent to 2-D constraint v==ax+by+c over the interval [lmpx,...
Psysteme sc_oppose(Psysteme ps)
package sc
Pcontrainte p_eg_fin
ensemble des fonctions utilisees dans le programme 'sc_gram.y' permettant de construire la structure ...
Pvecteur p_pred
pointeur sur le predecesseur du couple courant
Psysteme sc_reversal(Psysteme sc)
Psysteme sc_reversal(Psysteme sc)
void new_ident(Psysteme ps, Variable s)
void new_ident(Psysteme ps, char s[]): fonction introduisant un nouvel identificateur dans la liste d...
void init_globals()
void init_globals: initialisation des variables globales
Variable rec_ident(Psysteme ps, Variable s)
int rec_ident(Psysteme ps, char * s): cette fonction recherche dans la liste des variables du systeme...
Pcontrainte contrainte_reversal(Pcontrainte c)
Pcontrainte contrainte_reversal(Pcontrainte c)
Pcontrainte p_ineg_fin
pointeur sur la derniere inegalite
Pvecteur p_membre_courant
void creer_eg(Psysteme ps, Pcontrainte peq)
void creer_eg(Psysteme ps,Pcontrainte peq): ajout de la contrainte (egalite) peq au systeme ps.
void creer_ineg(Psysteme ps, Pcontrainte peq, int sens)
void creer_ineg(Psysteme ps, Pcontrainte peq, int sens): ajout d'une nouvelle inegalite peq dans la l...
bool sc_simplex_feasibility_ofl_ctrl(Psysteme sys, int ofl_ctrl)
Main Function.
void partial_pivot_direct(frac *X, frac B, frac C, frac D, bool ofl_ctrl)
void frac_simpl(Value *a, Value *b)
void full_pivot(frac *X, frac A, frac B, frac C, frac D, bool ofl_ctrl)
void pivot(frac *X, frac A, frac B, frac C, frac D, bool ofl_ctrl)
void frac_div(frac *x, frac y, frac z, bool ofl_ctrl)
void partial_pivot(frac *X, frac B, frac C, frac D, bool ofl_ctrl)
void frac_mul(frac *x, frac y, frac z, bool ofl_ctrl)
computes x = simplify(y*z)
bool sc_simplex_feasibility_ofl_ctrl_fixprec(Psysteme sc, int ofl_ctrl)
fonction de calcul de la faisabilite' d'un systeme d'equations et d'inequations Auteur : Robert Mahl,...
void full_pivot_direct(frac *X, frac A, frac B, frac C, frac D, bool ofl_ctrl)
computes X = A - B*C/D, but does not try to avoid arithmetic exceptions
void partial_pivot_sioux(frac *X, frac B, frac C, frac D, bool ofl_ctrl)
idem if A==0
void frac_sub(frac *X, frac A, frac B, bool ofl_ctrl)
void full_pivot_sioux(frac *X, frac A, frac B, frac C, frac D, bool ofl_ctrl)
void frac_init(frac *f, int n)
void frac_simplifie(frac *f)
simplifie normalizes fraction f
Psysteme sc_sort_constraints(Psysteme ps, Pbase base_index)
void sc_triang_elim_redund_n_first(Psysteme s, int n)
void sc_triang_elim_redund_n_first(s, n) Psysteme s; int n;
Pvecteur highest_rank_pvector(Pvecteur v, Pbase b, int *prank)
returns the highest rank pvector of v in b, of rank *prank
Pcontrainte contrainte_sort(Pcontrainte c, Pbase base, Pbase sort_base, bool inner_first, bool complex_first)
Psysteme sc_build_triang_elim_redund(Psysteme s, Pbase indexes)
outer to inner
Pcontrainte constraints_sort_with_compare(Pcontrainte c, Pbase sort_base, constraint_cmp_func_t compare, void *context)
Psysteme sc_sort_constraints_simplest_first(Psysteme ps, Pbase base_index)
Psysteme sc_triang_elim_redund(Psysteme ps, Pbase base_index)
sort contrainte c, base b, relatively to sort_base, as defined by the switches.
void move_n_first_constraints(Pcontrainte *source, Pcontrainte *target, int n)
void move_n_first_constraints(source, target, n) Pcontrainte *source, *target; int n;
Pvecteur vect_printout_order(Pvecteur v, int(*compare)(Pvecteur *, Pvecteur *))
Try to guess the print out order for an equality already lexicographically sorted.
bool sc_remove_large_coef(Psysteme sc, Value val, bool equalities, bool inequalities)
remove constraints with large coefs, possibly to avoid overflows and to keep systems as simple as pos...
Psysteme sc_elim_var(Psysteme sc, Variable v)
package sur les systemes de contraintes sc
void sc_chg_var(Psysteme s, Variable v_old, Variable v_new)
void sc_chg_var(Psysteme s, Variable v_old, Variable v_new) this function replace the variable v_old ...
void sc_vect_sort(Psysteme s, int(*compare)(Pvecteur *, Pvecteur *))
the name is self explanatory, I guess.
void sc_lexicographic_sort(Psysteme sc, int(*compare)(Pvecteur *, Pvecteur *))
Minimize first the lexico-graphic weight of each constraint according to the comparison function "com...
void sc_sort(Psysteme sc, Pbase sort_base, int(*compare)(Pvecteur *, Pvecteur *))
SORT a Psysteme according to sort_base and compare (given to qsort).
bool var_in_sc_p(Psysteme sc, Variable var)
bool var_in_sc_p(Psysteme sc, Variable var) Cette fonction teste si la variable est contrainte par le...
bool var_in_lcontrainte_p(Pcontrainte pc, Variable var)
Check if variable var appears in at least on of the constraints in constraint list pc with a non-zero...
Variable creat_new_var(Psysteme ps)
char * noms_var(int i): cette fonction convertit un numero de variable en chaine de caracteres
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
char *(* get_variable_name_t)(Variable)
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....