unaires.c File Reference

#include <stdio.h>
#include "linear_assert.h"
#include <stdlib.h>
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"

Include dependency graph for unaires.c:

Go to the source code of this file.

Functions
void	norm_eq (Pcontrainte nr)
	PACKAGE CONTRAINTE - OPERATIONS UNAIRES. More...
void	contrainte_chg_sgn (Pcontrainte c)
	void contrainte_chg_sgn(Pcontrainte eq): changement de signe d'une contrainte, i.e. More...
void	contrainte_reverse (Pcontrainte c)
	void contrainte_reverse(Pcontrainte eq): changement de signe d'une contrainte, i.e. More...
void	eq_set_vect_nul (Pcontrainte c)
	void_eq_set_vect_nul(Pcontrainte c): transformation d'une contrainte en une contrainte triviale 0 == 0 More...
Pcontrainte	contrainte_translate (Pcontrainte c, Pbase b, char *(*variable_name)())
	Pcontrainte contrainte_translate(Pcontrainte c, Pbase b, char * (*variable_name)()): normalisation des vecteurs de base utilises dans c par rapport a la base b utilisant les "noms" des vecteurs de base; en sortie tous les vecteurs de base utilises dans c appartiennent a b;. More...
Pcontrainte	contrainte_variable_rename (Pcontrainte c, Variable v_old, Variable v_new)
	Pcontrainte contrainte_variable_rename(Pcontrainte c, Variable v_old, Variable v_new): rename the potential coordinate v_old in c as v_new. More...
void	Pcontrainte_separate_on_vars (Pcontrainte initial, Pbase vars, Pcontrainte *pwith, Pcontrainte *pwithout)
	void Pcontrainte_separate_on_vars(initial, vars, pwith, pwithout) Pcontrainte initial; Pbase vars; Pcontrainte *pwith, *pwithout; More...
void	constraints_for_bounds (Variable var, Pcontrainte *pinit, Pcontrainte *plower, Pcontrainte *pupper)
	void constraints_for_bounds(var, pinit, plower, pupper) Variable var; Pcontrainte *pinit, *plower, *pupper; IN: var, *pinit; OUT: *pinit, *plower, *pupper; More...
Pcontrainte	contrainte_dup_extract (Pcontrainte c, Variable var)
	Pcontrainte contrainte_dup_extract(c, var) Pcontrainte c; Variable var;. More...
Pcontrainte	contrainte_extract (Pcontrainte *pc, Pbase base, Variable var)
	Pcontrainte contrainte_extract(pc, base, var) Pcontrainte *pc; Pbase base; Variable var;. More...
int	level_contrainte (Pcontrainte pc, Pbase base_index)
	int level_contrainte(Pcontrainte pc, Pbase base_index) compute the level (rank) of the constraint pc in the nested loops. More...
void	contrainte_vect_sort (Pcontrainte c, int *compare)
	it sorts the vectors as expected. More...
Pcontrainte	contrainte_var_min_coeff (Pcontrainte contraintes, Variable v, Value *coeff, bool rm_if_not_first_p)
	Pcontrainte contrainte_var_min_coeff(Pcontrainte contraintes, Variable v, int *coeff) input : a list of constraints (euqalities or inequalities), a variable, and the location of an integer. More...
int	equation_lexicographic_compare (Pcontrainte c1, Pcontrainte c2, int(*compare)(Pvecteur *, Pvecteur *))
static int	internal_equation_compare (Pcontrainte *pc1, Pcontrainte *pc2)
int	inequality_lexicographic_compare (Pcontrainte c1, Pcontrainte c2, int(*compare)(Pvecteur *, Pvecteur *))
static int	internal_inequality_compare (Pcontrainte *pc1, Pcontrainte *pc2)
Pcontrainte	equations_lexicographic_sort (Pcontrainte cl, int(*compare)(Pvecteur *, Pvecteur *))
Pcontrainte	inequalities_lexicographic_sort (Pcontrainte cl, int(*compare)(Pvecteur *, Pvecteur *))
Pcontrainte	constraints_lexicographic_sort (Pcontrainte cl, int(*compare)(Pvecteur *, Pvecteur *))
	For historical reasons, equal to equations_lexicographic_sort() More...
Pcontrainte	constraints_lexicographic_sort_generic (Pcontrainte cl, int(*compare)(Pvecteur *, Pvecteur *), bool is_equation)
Variable	contrainte_simple_equality (Pcontrainte e)
	returns whether a constraint is a simple equality: X == 12 the system is expected to be normalized? More...

Variables
static int(*	lexicographic_compare )(Pvecteur *, Pvecteur *) = NULL
	Required because qsort (and C) do no let us parametrize the comparison function (no lambda closure). More...

Function Documentation

constraints_for_bounds()

void constraints_for_bounds	(	Variable	var,
		Pcontrainte *	pinit,
		Pcontrainte *	plower,
		Pcontrainte *	pupper
	)

void constraints_for_bounds(var, pinit, plower, pupper) Variable var; Pcontrainte *pinit, *plower, *pupper; IN: var, *pinit; OUT: *pinit, *plower, *pupper;

separate the constraints involving var for upper and lower bounds The constraints are removed from the original system. everything is touched. Should be fast because there is no allocation.

FC 28/11/94

v==0

Parameters

var	ar
pinit	init
plower	lower
pupper	upper

Definition at line 176 of file unaires.c.

{
    Value 
        v;
    Pcontrainte
        c, next,
        remain = NULL,
        lower = NULL,
        upper = NULL;
 
    for(c = *pinit, next=(c==NULL ? NULL : c->succ); 
        c!=NULL; 
        c=next, next=(c==NULL ? NULL : c->succ))
    {
        v = vect_coeff(var, c->vecteur);
 
        if (value_pos_p(v))
            c->succ = upper, upper = c;
        else if (value_neg_p(v))
            c->succ = lower, lower = c;
        else /* v==0 */
            c->succ = remain, remain = c;
    }
 
    *pinit = remain,
    *plower = lower,
    *pupper = upper;
}

References Scontrainte::succ, value_neg_p, value_pos_p, vect_coeff(), and Scontrainte::vecteur.

Referenced by do_array_expansion(), do_check_isolate_statement_preconditions_on_call(), do_isolate_statement_preconditions_satisified_p(), do_solve_hardware_constraints_on_nb_proc(), make_rectangular_area(), region_to_minimal_dimensions(), statement_insertion_fix_access(), systeme_to_loop_nest(), and variable_to_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

constraints_lexicographic_sort()

Pcontrainte constraints_lexicographic_sort	(	Pcontrainte	cl,
		int(*)(Pvecteur *, Pvecteur *)	compare
	)

For historical reasons, equal to equations_lexicographic_sort()

Parameters

cl

l

Definition at line 461 of file unaires.c.

{
    Pcontrainte result = CONTRAINTE_UNDEFINED;
 
    result = constraints_lexicographic_sort_generic(cl, compare, true);
 
    return result;
}

References constraints_lexicographic_sort_generic(), and CONTRAINTE_UNDEFINED.

Here is the call graph for this function:

constraints_lexicographic_sort_generic()

Pcontrainte constraints_lexicographic_sort_generic	(	Pcontrainte	cl,
		int(*)(Pvecteur *, Pvecteur *)	compare,
		bool	is_equation
	)

the temporary table is created and initialized

sort!

the vector is regenerated in order

clean and return

Parameters

cl	l
is_equation	s_equation

Definition at line 472 of file unaires.c.

{
    int n = nb_elems_list(cl);
    Pcontrainte result = CONTRAINTE_UNDEFINED;
    Pcontrainte * table = NULL;
    Pcontrainte * elem = NULL;
    Pcontrainte ce;
 
    if ( n==0 || n==1 )
        return cl;
 
    lexicographic_compare = compare;
 
    /*  the temporary table is created and initialized
     */
    table = (Pcontrainte*) malloc(sizeof(Pcontrainte)*n);
    assert(table!=NULL);
 
    for (ce=cl, elem=table; ce!=CONTRAINTE_UNDEFINED; ce=ce->succ, elem++)
        *elem=ce;
 
    /*  sort!
     */
    if(is_equation)
        qsort((char *) table, n, sizeof(Pcontrainte),
              (int (*)()) internal_equation_compare);
    else
        qsort((char *) table, n, sizeof(Pcontrainte),
              (int (*)()) internal_inequality_compare);
 
    /*  the vector is regenerated in order
     */
    for (elem=table; n>1; elem++, n--)
        (*elem)->succ=*(elem+1);
 
    (*elem)->succ= CONTRAINTE_UNDEFINED;
    
    /*  clean and return
     */
    result = *table;
    free(table);
    return result;
}

References assert, CONTRAINTE_UNDEFINED, free(), internal_equation_compare(), internal_inequality_compare(), lexicographic_compare, malloc(), nb_elems_list(), and Scontrainte::succ.

Referenced by constraints_lexicographic_sort(), equations_lexicographic_sort(), and inequalities_lexicographic_sort().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_chg_sgn()

void contrainte_chg_sgn

(

Pcontrainte

c

)

void contrainte_chg_sgn(Pcontrainte eq): changement de signe d'une contrainte, i.e.

multiplication par -1. Les equations ne sont pas modifiees mais les inequations sont transformees.

Ancien nom: ch_sgn

Definition at line 56 of file unaires.c.

{
    vect_chg_sgn(c->vecteur);
}

References vect_chg_sgn().

Referenced by contrainte_reverse(), contrainte_var_min_coeff(), eq_redund_with_sc_p(), make_tile_constraints(), sc_supress_same_constraints(), and tile_membership().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_dup_extract()

Pcontrainte contrainte_dup_extract	(	Pcontrainte	c,
		Variable	var
	)

Pcontrainte contrainte_dup_extract(c, var) Pcontrainte c; Variable var;.

returns a copy of the constraints of c which contain var.

FC 27/09/94

Parameters

var

ar

Definition at line 215 of file unaires.c.

{
    Pcontrainte
        result = NULL,
        pc, ctmp;
 
    for (pc=c; pc!=NULL; pc=pc->succ)
        if ((var==NULL) || vect_coeff(var, pc->vecteur)!=0)
            ctmp = contrainte_dup(pc),
            ctmp->succ = result,
            result = ctmp;
    
    return(result);
}

References contrainte_dup(), Scontrainte::succ, and vect_coeff().

Referenced by algorithm_row_echelon_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_extract()

Pcontrainte contrainte_extract	(	Pcontrainte *	pc,
		Pbase	base,
		Variable	var
	)

Pcontrainte contrainte_extract(pc, base, var) Pcontrainte *pc; Pbase base; Variable var;.

returns the constraints of *pc of which the higher rank variable from base is var. These constraints are removed from *pc.

FC 27/09/94

Parameters

pc	c
base	ase
var	ar

Definition at line 242 of file unaires.c.

{
    int
        rank = rank_of_variable(base, var);
    Pcontrainte
        ctmp = NULL,
        result = NULL,
        cprev = NULL,
        c = *pc;
 
    while (c!=NULL)
    {
        if (search_higher_rank(c->vecteur, base)==rank)
        {
            /*
             * c must be extracted
             */
            ctmp = c->succ,
            c->succ = result,
            result = c,
            c = ctmp;
            
            if (cprev==NULL)
                *pc = ctmp;
            else
                cprev->succ=ctmp;
        }
        else
            c=c->succ, 
            cprev=(cprev==NULL) ? *pc : cprev->succ;
    }
 
    return(result);
}

References base, rank, rank_of_variable(), search_higher_rank(), and Scontrainte::succ.

Here is the call graph for this function:

contrainte_reverse()

void contrainte_reverse

(

Pcontrainte

c

)

void contrainte_reverse(Pcontrainte eq): changement de signe d'une contrainte, i.e.

multiplication par -1, et ajout de la constante 1.

Definition at line 67 of file unaires.c.

{
    contrainte_chg_sgn(c);
    vect_add_elem(&(c->vecteur), TCST, VALUE_ONE);
}

References contrainte_chg_sgn(), TCST, VALUE_ONE, and vect_add_elem().

Referenced by build_integer_sc_nredund(), build_sc_nredund_1pass_ofl_ctrl(), ineq_redund_with_sc_p(), sc_elim_redund_with_first_ofl_ctrl(), sc_inequations_elim_redund(), sc_triang_elim_redund(), and sc_triang_elim_redund_n_first().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_simple_equality()

Variable contrainte_simple_equality

(

Pcontrainte

e

)

returns whether a constraint is a simple equality: X == 12 the system is expected to be normalized?

Definition at line 521 of file unaires.c.

{
  Pvecteur v = e->vecteur;
  int size = vect_size(v);
  switch (size) {
  case 0: return NULL;
  case 1: if (v->var) return v->var; else return NULL;
  case 2: 
    if (v->var && !v->succ->var) return v->var;
    if (!v->var && v->succ->var) return v->succ->var;
  }
  return NULL;
}

References Svecteur::succ, Svecteur::var, vect_size(), and Scontrainte::vecteur.

Here is the call graph for this function:

contrainte_translate()

Pcontrainte contrainte_translate	(	Pcontrainte	c,
		Pbase	b,
		char * (*)()	variable_name
	)

Pcontrainte contrainte_translate(Pcontrainte c, Pbase b, char * (*variable_name)()): normalisation des vecteurs de base utilises dans c par rapport a la base b utilisant les "noms" des vecteurs de base; en sortie tous les vecteurs de base utilises dans c appartiennent a b;.

Definition at line 99 of file unaires.c.

{
    if(!CONTRAINTE_UNDEFINED_P(c))
        contrainte_vecteur(c) = vect_translate(contrainte_vecteur(c), b,
                                               variable_name);
 
    return c;
}

References CONTRAINTE_UNDEFINED_P, contrainte_vecteur, variable_name(), and vect_translate().

Here is the call graph for this function:

contrainte_var_min_coeff()

Pcontrainte contrainte_var_min_coeff	(	Pcontrainte	contraintes,
		Variable	v,
		Value *	coeff,
		bool	rm_if_not_first_p
	)

Pcontrainte contrainte_var_min_coeff(Pcontrainte contraintes, Variable v, int *coeff) input : a list of constraints (euqalities or inequalities), a variable, and the location of an integer.

output : the constraint in "contraintes" where the coefficient of "v" is the smallest (but non-zero). modifies : nothing. comment : the returned constraint is not removed from the list if rm_if_not_first_p is false. if rm_if_not_first_p is true, the returned contraint is remove only if it is not the first constraint.

Parameters

contraintes	ontraintes
coeff	oeff
rm_if_not_first_p	m_if_not_first_p

Definition at line 345 of file unaires.c.

{
    Value sc = VALUE_ZERO, cv = VALUE_ZERO;
    Pcontrainte result, eq, pred, eq1;
 
    if (contraintes == NULL) 
        return(NULL);
 
    result = pred = eq1 = NULL;
    
    for (eq = contraintes; eq != NULL; eq = eq->succ) {
        Value c, ca;
        c = vect_coeff(v, eq->vecteur);
        ca = value_abs(c);
        if ((value_lt(ca,cv) && value_pos_p(ca)) || 
            (value_zero_p(cv) && value_notzero_p(c))) {
            cv = ca;
            sc = c;
            result = eq;
            pred = eq1;
        }
    }
 
    if (value_neg_p(sc))
        contrainte_chg_sgn(result);
    
    if (rm_if_not_first_p && pred != NULL) {
        pred->succ = result->succ;
        result->succ = NULL;
    }
  
    *coeff = cv;
    return result;
}

References contrainte_chg_sgn(), eq, Scontrainte::succ, value_abs, value_lt, value_neg_p, value_notzero_p, value_pos_p, VALUE_ZERO, value_zero_p, vect_coeff(), and Scontrainte::vecteur.

Referenced by better_elim_var_with_eg(), new_elim_var_with_eg(), remove_variables_if_possible(), and sc_projection_optim_along_vecteur_ofl().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_variable_rename()

Pcontrainte contrainte_variable_rename	(	Pcontrainte	c,
		Variable	v_old,
		Variable	v_new
	)

Pcontrainte contrainte_variable_rename(Pcontrainte c, Variable v_old, Variable v_new): rename the potential coordinate v_old in c as v_new.

Parameters

v_old	_old
v_new	_new

Definition at line 115 of file unaires.c.

{
    if(!CONTRAINTE_UNDEFINED_P(c))
        contrainte_vecteur(c) = vect_variable_rename(contrainte_vecteur(c), 
                                                     v_old, v_new);
 
    return c;
}

References CONTRAINTE_UNDEFINED_P, contrainte_vecteur, and vect_variable_rename().

Referenced by sc_variable_rename().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_vect_sort()

void contrainte_vect_sort	(	Pcontrainte	c,
		int *	compare
	)

it sorts the vectors as expected.

FC 24/11/94

Definition at line 323 of file unaires.c.

{
    for (; c!=NULL; c=c->succ)
        vect_sort_in_place(&c->vecteur, compare);
}

References Scontrainte::succ, vect_sort_in_place(), and Scontrainte::vecteur.

Here is the call graph for this function:

eq_set_vect_nul()

void eq_set_vect_nul

(

Pcontrainte

c

)

void_eq_set_vect_nul(Pcontrainte c): transformation d'une contrainte en une contrainte triviale 0 == 0

cette fonction est utile lorsque l'on veut eliminer plusieurs
contraintes du systeme sans avoir a le restructurer apres chaque
elimination.

Pour eliminer toutes ces "fausses" contraintes on utilise a la fin la
fonction "syst_elim_eq" (ou "sc_rm_empty_constraints"...)

Definition at line 84 of file unaires.c.

{
    if(!CONTRAINTE_UNDEFINED_P(c)) {
        vect_rm(contrainte_vecteur(c));
        contrainte_vecteur(c) = VECTEUR_NUL;
    }
}

References CONTRAINTE_UNDEFINED_P, contrainte_vecteur, vect_rm(), and VECTEUR_NUL.

Referenced by elim_redund_sc_with_sc(), sc_bounded_normalization(), sc_elim_db_constraints(), sc_elim_double_constraints(), sc_elim_redund_with_first_ofl_ctrl(), sc_elim_simple_redund_with_eq(), sc_elim_simple_redund_with_ineq(), sc_inequations_elim_redund(), sc_kill_db_eg(), sc_safe_elim_db_constraints(), sc_safe_kill_db_eg(), sc_strong_normalize_and_check_feasibility(), sc_transform_ineg_in_eg(), sc_triang_elim_redund(), sc_triang_elim_redund_n_first(), simplify_big_coeff(), and sys_int_redond().

Here is the call graph for this function:

Here is the caller graph for this function:

equation_lexicographic_compare()

int equation_lexicographic_compare	(	Pcontrainte	c1,
		Pcontrainte	c2,
		int(*)(Pvecteur *, Pvecteur *)	compare
	)

it is assumed that constraints c1 and c2 are already lexicographically sorted

Parameters

c1	1
c2	2

Definition at line 395 of file unaires.c.

{
    /* it is assumed that constraints c1 and c2 are already
       lexicographically sorted */
    int cmp = 0;
 
    cmp = vect_lexicographic_compare(c1->vecteur, c2->vecteur, compare);
 
    return cmp;
}

References vect_lexicographic_compare(), and Scontrainte::vecteur.

Referenced by internal_equation_compare().

Here is the call graph for this function:

Here is the caller graph for this function:

equations_lexicographic_sort()

Pcontrainte equations_lexicographic_sort	(	Pcontrainte	cl,
		int(*)(Pvecteur *, Pvecteur *)	compare
	)

Parameters

cl

l

Definition at line 438 of file unaires.c.

{
    Pcontrainte result = CONTRAINTE_UNDEFINED;
 
    result = constraints_lexicographic_sort_generic(cl, compare, true);
 
    return result;
}

References constraints_lexicographic_sort_generic(), and CONTRAINTE_UNDEFINED.

Referenced by sc_lexicographic_sort().

Here is the call graph for this function:

Here is the caller graph for this function:

inequalities_lexicographic_sort()

Pcontrainte inequalities_lexicographic_sort	(	Pcontrainte	cl,
		int(*)(Pvecteur *, Pvecteur *)	compare
	)

Parameters

cl

l

Definition at line 449 of file unaires.c.

{
    Pcontrainte result = CONTRAINTE_UNDEFINED;
 
    result = constraints_lexicographic_sort_generic(cl, compare, false);
 
    return result;
}

References constraints_lexicographic_sort_generic(), and CONTRAINTE_UNDEFINED.

Referenced by sc_lexicographic_sort().

Here is the call graph for this function:

Here is the caller graph for this function:

inequality_lexicographic_compare()

int inequality_lexicographic_compare	(	Pcontrainte	c1,
		Pcontrainte	c2,
		int(*)(Pvecteur *, Pvecteur *)	compare
	)

it is assumed that constraints c1 and c2 are already lexicographically sorted

Parameters

c1	1
c2	2

Definition at line 416 of file unaires.c.

{
    /* it is assumed that constraints c1 and c2 are already
       lexicographically sorted */
    int cmp = 0;
 
    cmp = vect_lexicographic_compare2(c1->vecteur, c2->vecteur, compare);
 
    return cmp;
}

References vect_lexicographic_compare2(), and Scontrainte::vecteur.

Referenced by internal_inequality_compare().

Here is the call graph for this function:

Here is the caller graph for this function:

internal_equation_compare()

static int internal_equation_compare ( Pcontrainte *  pc1, Pcontrainte *  pc2  )

static

Definition at line 408 of file unaires.c.

{
    int cmp = equation_lexicographic_compare(*pc1, *pc2, 
                                               lexicographic_compare);
    return cmp;
}

References equation_lexicographic_compare(), and lexicographic_compare.

Referenced by constraints_lexicographic_sort_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

internal_inequality_compare()

static int internal_inequality_compare ( Pcontrainte *  pc1, Pcontrainte *  pc2  )

static

Definition at line 429 of file unaires.c.

{
    int cmp = inequality_lexicographic_compare(*pc1, *pc2, 
                                               lexicographic_compare);
    return cmp;
}

References inequality_lexicographic_compare(), and lexicographic_compare.

Referenced by constraints_lexicographic_sort_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

level_contrainte()

int level_contrainte	(	Pcontrainte	pc,
		Pbase	base_index
	)

int level_contrainte(Pcontrainte pc, Pbase base_index) compute the level (rank) of the constraint pc in the nested loops.

base_index is the index basis in the good order The result corresponds to the rank of the greatest index in the constraint, and the sign of the result corresponds to the sign of the coefficient of this index

For instance: base_index :I->J->K , I - J <=0 ==> level -2 I + J + K <=0 ==> level +3

Parameters

pc	c
base_index	ase_index

Definition at line 292 of file unaires.c.

{
    Pvecteur pv;
    Pbase pb;
    int level = 0;
    int i;
    int sign=1;
    bool trouve = false;
 
    for (pv = pc->vecteur;
         pv!=NULL;
         pv = pv->succ)
    {
        for (i=1, trouve=false, pb=base_index;
             pb!=NULL && !trouve;
             i++, pb=pb->succ)
            if (pv->var == pb->var)
            {
                trouve = true;
                if (i>level)
                    level = i, sign = value_sign(pv->val);
            }
    }
    return(sign*level);
}

References level, Svecteur::succ, Svecteur::val, value_sign, and Svecteur::var.

Referenced by make_bound_expression(), and sc_triang_elim_redund().

Here is the caller graph for this function:

norm_eq()

void norm_eq

(

Pcontrainte

nr

)

PACKAGE CONTRAINTE - OPERATIONS UNAIRES.

unaires.c

norm_eq: normalisation d'une contrainte par le pgcd de TOUS les coefficients, i.e. y compris le terme constant

Parameters

nr

r

Definition at line 44 of file unaires.c.

{
    vect_normalize(nr->vecteur);
}

References vect_normalize().

Referenced by norm_syst().

Here is the call graph for this function:

Here is the caller graph for this function:

Pcontrainte_separate_on_vars()

void Pcontrainte_separate_on_vars	(	Pcontrainte	initial,
		Pbase	vars,
		Pcontrainte *	pwith,
		Pcontrainte *	pwithout
	)

void Pcontrainte_separate_on_vars(initial, vars, pwith, pwithout) Pcontrainte initial; Pbase vars; Pcontrainte *pwith, *pwithout;

IN: initial, vars

OUT: pwith, pwithout

builds two Pcontraintes from the one given, using the constraint_without_vars criterium.

(c) FC 16/05/94

Parameters

initial	nitial
vars	ars
pwith	with
pwithout	without

Definition at line 140 of file unaires.c.

{
    Pcontrainte
        c = (Pcontrainte) NULL,
        new = CONTRAINTE_UNDEFINED;
 
    for(c=initial, 
        *pwith=(Pcontrainte)NULL,
        *pwithout=(Pcontrainte)NULL; 
        c!=(Pcontrainte) NULL;
        c=c->succ)
        if (constraint_without_vars(c, vars))
            new = contrainte_make(vect_dup(c->vecteur)),
            new->succ = *pwithout, 
            *pwithout = new;
        else
            new = contrainte_make(vect_dup(c->vecteur)),
            new->succ = *pwith, 
            *pwith = new;
}

References constraint_without_vars(), contrainte_make(), CONTRAINTE_UNDEFINED, Scontrainte::succ, vect_dup(), and Scontrainte::vecteur.

Referenced by get_other_constraints(), and sc_separate_on_vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

lexicographic_compare

int(* lexicographic_compare) (Pvecteur *, Pvecteur *) ( Pvecteur *  , Pvecteur *    ) = NULL

static

Required because qsort (and C) do no let us parametrize the comparison function (no lambda closure).

Definition at line 392 of file unaires.c.

Referenced by constraints_lexicographic_sort_generic(), internal_equation_compare(), and internal_inequality_compare().