pip_interface.c File Reference

#include <setjmp.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "genC.h"
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "matrix.h"
#include "ri.h"
#include "constants.h"
#include "ri-util.h"
#include "misc.h"
#include "bootstrap.h"
#include "complexity_ri.h"
#include "database.h"
#include "graph.h"
#include "dg.h"
#include "paf_ri.h"
#include "parser_private.h"
#include "property.h"
#include "reduction.h"
#include "text.h"
#include "paf-util.h"
#include "static_controlize.h"
#include "pip.h"

Include dependency graph for pip_interface.c:

Go to the source code of this file.

Data Structures
struct	S
	Base of the parameters. More...

Macros
#define	Nil   1
	Internal variables More...
#define	If   2
#define	List   3
#define	Form   4
#define	New   5
#define	Div   6
#define	Val   7

Functions
int	integer_sol_edit (int i)
	Useful for the sorting of the variables in the system's Pvecteur. More...
int	rational_sol_edit (int i)
	========================================================================== More...
int	new_sol_edit (int i)
	========================================================================== More...
void	new_ecrit_ligne (Pvecteur p_vect, Pbase p_sys_base, int nb_var, Entier *in_val)
	========================================================================== More...
Tableau *	sc_to_tableau (Psysteme in_ps, int nb_var)
	========================================================================== More...

Variables
Pbase	base_var_ref
	Name : pip_interface.c Package : paf-util Author : A. More...
Pbase	base_ref
	Base of the unknowns. More...
Pbase	old_base
	Base of the parameters. More...
Pbase	old_base_var
	Base of the unknowns. More...
int	ind_min_max
quast	quast_act
	Global variables More...
expression	expression_act
struct S	sol_space []
Pvecteur	vect_for_sort

Macro Definition Documentation

Div

#define Div   6

Definition at line 102 of file pip_interface.c.

Form

#define Form   4

Definition at line 100 of file pip_interface.c.

If

#define If   2

Definition at line 98 of file pip_interface.c.

List

#define List   3

Definition at line 99 of file pip_interface.c.

New

#define New   5

Definition at line 101 of file pip_interface.c.

Nil

#define Nil   1

Internal variables

Definition at line 97 of file pip_interface.c.

Val

#define Val   7

Definition at line 103 of file pip_interface.c.

Function Documentation

integer_sol_edit()

int integer_sol_edit

(

int

i

)

Useful for the sorting of the variables in the system's Pvecteur.

========================================================================== int integer_sol_edit((int) i) AL 28/03/94 We will simulate a patern matching when the solution is produced. Warning : we use here the Feautrier version of the pgcd (accept negative nb).

We have a newparm

call to Div case

Let's take the first vector : vecteur2 (case Form)

Call to Form

Take all the coefficient2

Should not be called here

Take the corresponding new parameter

Should not happen here

Look at the superquast

Our quast is a conditional

Take vecteur1 part of the if

Call to case Form

Should not be called here

Take true super quast

Take false super quast

Quast is a list of solutions

call to the liste_vecteur

Take each vecteur (call to Form case)

Should not happen here

We have an undefined quast

This should not happen any more

This case should not happen any more

This case should not happen any more

Definition at line 115 of file pip_interface.c.

{
    int j, n, first_entier, second_entier = 0, longueur_liste;
    struct S *p;
    Entier N, D, d;
    p = sol_space + i;
 
    switch(p->flags) {
        /* We have a newparm */
    case New : n = p->param1;
        first_entier = n;
        i++; p++; /* call to Div case */
        /* Let's take the first vector : vecteur2 (case Form) */
        i++; p++; /* Call to Form */
        n = p->param1;
        /* Take all the coefficient2 */
        init_vecteur();
        for(j = 0; j<n; j++) {
            i++; p++;
            N = p->param1; D = p->param2;
            d = sol_pgcd(N, D);
 
            if(d == D){ 
                if(N/d < 0) ecrit_coeff_neg2( -N/d );
                else ecrit_coeff2( N/d );
            }
            /* Should not be called here */
            else{ pips_internal_error("Division 1 in newparm");
              }
        }
        i++; p++;
 
        /* Take the corresponding new parameter */
        N = p->param1; D = p->param2;
        d = sol_pgcd(N, D);
        if(d == D){
            second_entier =  N/d;
        }
        /* Should not happen here */
        else{
            pips_internal_error("Division 2 in newparm");
          }
        i++; p++;
 
        ajoute_new_var( second_entier, first_entier );
 
        i = integer_sol_edit( i ); /* Look at the superquast */
        
        retire_par_de_pile();
        break;
 
        /* Our quast is a conditional */
    case If  : init_quast();
        /* Take vecteur1 part of the if */
        i++; p++; /* Call to case Form */
        
        creer_Psysteme();
 
        n = p->param1;
        for(j = 0; j<n; j++) {
            i++; p++;
            N = p->param1; D = p->param2;
            d = sol_pgcd(N, D);
            if(d == D){
                ecrit_coeff1( N/d );
            }
            /* Should not be called here */
            else{ pips_internal_error("Division 3 in newparm");
              }
        }
 
        creer_predicat();
        i++; p++;
 
        /* Take true super quast */
        i = integer_sol_edit(i);
 
        creer_true_quast();
 
        /* Take false super quast */
        i = integer_sol_edit(i);
 
        fait_quast_value();
        
        fait_quast();
        break;
 
        /* Quast is a list of solutions */
    case List: init_quast();
        longueur_liste = p->param1;
        if (longueur_liste > 0) init_liste_vecteur();
 
        i++; p++; /* call to the liste_vecteur */
        /* Take each vecteur (call to Form case) */
        while(longueur_liste--) {
            init_vecteur();
            n = p->param1;
            for(j = 0; j<n; j++) {
                i++; p++;
                N = p->param1; D = p->param2;
                d = sol_pgcd(N, D);
                if(d == D){
                    if (N/d < 0) ecrit_une_var_neg(-N/d);
                    else ecrit_une_var( N/d );
                }
                /* Should not happen here */
                else{
                    pips_internal_error("Division 4 in newparm");
                  }
            }
            ecrit_liste_vecteur();
            i++; p++;
        }
 
        creer_quast_value();
        fait_quast();
        break;
 
        /* We have an undefined quast */
    case Nil : init_quast();
        creer_quast_value();
        fait_quast();
        i++; break;
 
        /* This should not happen any more */
    case Form: pips_internal_error("Form case call");
        break;
 
        /* This case should not happen any more */
    case Div:   pips_internal_error("Div case call");
        break;
 
        /* This case should not happen any more */
    case Val:  pips_internal_error("Val case call");
        break;
 
    default  : pips_internal_error("Undefined kind of quast ");
    }
        
    return(i);
}

References ajoute_new_var(), creer_predicat(), creer_Psysteme(), creer_quast_value(), creer_true_quast(), D, Div, ecrit_coeff1(), ecrit_coeff2(), ecrit_coeff_neg2(), ecrit_liste_vecteur(), ecrit_une_var(), ecrit_une_var_neg(), Entier, fait_quast(), fait_quast_value(), S::flags, Form, If, init_liste_vecteur(), init_quast(), init_vecteur(), List, New, Nil, S::param1, S::param2, pips_internal_error, retire_par_de_pile(), sol_pgcd(), sol_space, and Val.

Referenced by pip_solve().

Here is the call graph for this function:

Here is the caller graph for this function:

new_ecrit_ligne()

void new_ecrit_ligne	(	Pvecteur	p_vect,
		Pbase	p_sys_base,
		int	nb_var,
		Entier *	in_val
	)

==========================================================================

void new_ecrit_ligne(p_vect, p_sys_base, nb_var, in_val) AL 6/12/93

Compteur de variables deja vues

We run over the base and fill in in_val

First, we put variables, then constant terms and then parameters

Definition at line 595 of file pip_interface.c.

{
        Pvecteur        base = (Pvecteur) p_sys_base;
        int             aux = 0;      /* Compteur de variables deja vues */
 
 
        /* We run over the base and fill in in_val */
        /* First, we put variables, then constant terms and then parameters */
        for(; (base != NULL) || (aux <= nb_var); aux++) {
                int val;
 
                if(aux == nb_var) val = (int) vect_coeff(TCST, p_vect);
                else  {
                        val = (int) vect_coeff(base->var, p_vect);
                        base = base->succ;
                }
 
                *(in_val+aux) = -val;
        }
}

References aux, base, int, TCST, and vect_coeff().

Referenced by sc_to_tableau().

Here is the call graph for this function:

Here is the caller graph for this function:

new_sol_edit()

int new_sol_edit

(

int

i

)

==========================================================================

int new_sol_edit((int) i) AL 8/12/93 We will simulate a patern matching when the solution is produced. Warning : we use here the Feautrier version of the pgcd (accept negative nb).

Just keep for compatibility. Should be thrown away AL 28 03 94.

We have a newparm

call to Div case

Let's take the first vector : vecteur2 (case Form)

Call to Form

Take all the coefficient2

Should not be called here

Take the corresponding new parameter

Should not happen here

Look at the superquast

Our quast is a conditional

Take vecteur1 part of the if

Call to case Form

Should not be called here

Take true super quast

Take false super quast

Quast is a list of solutions

call to the liste_vecteur

Take each vecteur (call to Form case)

Should not happen here

We have an undefined quast

This should not happen any more

This case should not happen any more

This case should not happen any more

Definition at line 423 of file pip_interface.c.

{
 int j, n, first_entier, second_entier = 0, longueur_liste;
 struct S *p;
 Entier N, D, d;
 p = sol_space + i;
 
 switch(p->flags) {
 
 
 
 
     /* We have a newparm */
     case New : n = p->param1;
                first_entier = n;
 
                i++; p++; /* call to Div case */
                /* Let's take the first vector : vecteur2 (case Form) */
                i++; p++; /* Call to Form */
                n = p->param1;
                /* Take all the coefficient2 */
                init_vecteur();
                for(j = 0; j<n; j++) {
                    i++; p++;
                    N = p->param1; D = p->param2;
                    d = sol_pgcd(N, D);
 
                    if(d == D){ 
                        if(N/d < 0) ecrit_coeff_neg2( -N/d );
                        else ecrit_coeff2( N/d );
                    }
                    /* Should not be called here */
                    else{ pips_internal_error("Division 1 in newparm");
                    }
                }
                i++; p++;
 
 
                /* Take the corresponding new parameter */
                N = p->param1; D = p->param2;
                d = sol_pgcd(N, D);
                if(d == D){ second_entier =  N/d;
                }
                /* Should not happen here */
                else{ pips_internal_error("Division 2 in newparm");
                }
                i++; p++;
 
                ajoute_new_var( second_entier, first_entier );
 
 
                i = new_sol_edit( i ); /* Look at the superquast */
 
                retire_par_de_pile();
                break;
 
 
 
    /* Our quast is a conditional */
     case If  : init_quast();
 
                /* Take vecteur1 part of the if */
                i++; p++; /* Call to case Form */
 
                creer_Psysteme();
 
                n = p->param1;
                for(j = 0; j<n; j++) {
                    i++; p++;
                    N = p->param1; D = p->param2;
                    d = sol_pgcd(N, D);
                    if(d == D){
                        ecrit_coeff1( N/d );
                    }
                    /* Should not be called here */
                    else{ pips_internal_error("Division 3 in newparm");
                    }
                }
 
                creer_predicat();
                i++; p++;
 
 
                /* Take true super quast */
                i = new_sol_edit(i);
 
 
                creer_true_quast();
 
 
                /* Take false super quast */
                i = new_sol_edit(i);
 
 
                fait_quast_value();
 
                fait_quast();
                break;
 
 
 
 
 
     /* Quast is a list of solutions */
     case List: init_quast();
                longueur_liste = p->param1;
                if (longueur_liste > 0) init_liste_vecteur();
 
 
                i++; p++; /* call to the liste_vecteur */
                /* Take each vecteur (call to Form case) */
                while(longueur_liste--) {
                        init_vecteur();
                        n = p->param1;
                        for(j = 0; j<n; j++) {
                                i++; p++;
                                N = p->param1; D = p->param2;
                                d = sol_pgcd(N, D);
                                if(d == D){
                                        if (N/d < 0) ecrit_une_var_neg(-N/d);
                                        else ecrit_une_var( N/d );
                                }
                                /* Should not happen here */
                                else{ pips_internal_error("Division 4 in newparm");
                                }
                        }
                        ecrit_liste_vecteur();
                        i++; p++;
                }
 
                creer_quast_value();
                fait_quast();
                break;
 
 
 
 
     /* We have an undefined quast */
     case Nil : init_quast();
                creer_quast_value();
                fait_quast();
                i++; break;
 
 
 
 
     /* This should not happen any more */
     case Form: pips_internal_error("Form case call");
                break;
 
     /* This case should not happen any more */
     case Div:  pips_internal_error("Div case call");
                break;
 
     /* This case should not happen any more */
     case Val:  pips_internal_error("Val case call");
                break;
 
 
     default  : pips_internal_error("Undefined kind of quast ");
    }
 
        
    return(i);
}

References ajoute_new_var(), creer_predicat(), creer_Psysteme(), creer_quast_value(), creer_true_quast(), D, Div, ecrit_coeff1(), ecrit_coeff2(), ecrit_coeff_neg2(), ecrit_liste_vecteur(), ecrit_une_var(), ecrit_une_var_neg(), Entier, fait_quast(), fait_quast_value(), S::flags, Form, If, init_liste_vecteur(), init_quast(), init_vecteur(), List, New, Nil, S::param1, S::param2, pips_internal_error, retire_par_de_pile(), sol_pgcd(), sol_space, and Val.

Here is the call graph for this function:

rational_sol_edit()

int rational_sol_edit

(

int

i

)

==========================================================================

int rational_sol_edit((int) i) AL 28/03/94 We will simulate a patern matching when the solution is produced. Warning : we use here the Feautrier version of the pgcd (accept negative nb).

We have a newparm

Our quast is a conditional

Take vecteur1 part of the if

Call to case Form

First scan to get the lcm (ppcm) of the denominator

Then write the new predicate

Take true super quast

Take false super quast

Quast is a list of solutions

call to the liste_vecteur

Take each vecteur (call to Form case)

First scan to get the lcm (ppcm) of the denominator

Then write the expression

We have an undefined quast

This should not happen any more

This case should not happen any more

This case should not happen any more

Definition at line 263 of file pip_interface.c.

{int j, n, longueur_liste;
 struct S *p,*p_init;
 Entier N, D, d;
 int    lcm, i_init;
 
 
 p = sol_space + i;
 
 switch(p->flags) {
 
 
 
 
     /* We have a newparm */
     case New: 
                pips_internal_error("There is a new parameter for a rational compute !");
                break;
 
 
    /* Our quast is a conditional */
     case If  : init_quast();
 
                /* Take vecteur1 part of the if */
                i++; p++; /* Call to case Form */
 
                creer_Psysteme();
 
                n = p->param1;
 
                /* First scan to get the lcm (ppcm) of the denominator */
                i_init = i;
                p_init = p;
                lcm = 1;
                for(j = 0; j<n; j++) {
                    i++; p++;
                    N = p->param1; D = p->param2;
                        d = sol_pgcd( N, D );
                        lcm = sol_ppcm( lcm, D/d );
                }
 
                /* Then write the new predicate */
                i = i_init;
                p = p_init;
                for(j = 0; j<n; j++) {
                    i++; p++;
                    N = p->param1; D = p->param2;
                    ecrit_coeff1( (lcm*N)/D );
                }
 
                creer_predicat();
                i++; p++;
 
 
                /* Take true super quast */
        i = rational_sol_edit(i);
 
 
                creer_true_quast();
 
 
                /* Take false super quast */
        i = rational_sol_edit(i);
 
 
                fait_quast_value();
 
                fait_quast();
        break;
 
 
 
 
 
     /* Quast is a list of solutions */
     case List: init_quast();
        longueur_liste = p->param1;
                if (longueur_liste > 0) init_liste_vecteur();
 
 
                i++; p++; /* call to the liste_vecteur */
                /* Take each vecteur (call to Form case) */
                while(longueur_liste--) {
                        init_vecteur();
                        n = p->param1;
 
                        /* First scan to get the lcm (ppcm) of the denominator */
                        i_init = i;
                        p_init = p;
                        lcm = 1;
                        for(j = 0; j<n; j++) {
                        i++; p++;
                        N = p->param1; D = p->param2;
                                d = sol_pgcd( N, D );
                                lcm = sol_ppcm( lcm, D/d );
                        }
 
                        /* Then write the expression */
                        i = i_init;
                        p = p_init;
                        for(j = 0; j<n; j++) {
                                i++; p++;
                                N = p->param1; D = p->param2;
                                d = (lcm*N)/D;
                                if (d < 0) ecrit_une_var_neg( -d );
                                else ecrit_une_var( d );
                        }
 
 
                        expression_act = make_op_exp(DIVIDE_OPERATOR_NAME,
                                                     expression_act,
                                                     int_to_expression(lcm));
                        ecrit_liste_vecteur();
                        i++; p++;
                }
 
                creer_quast_value();
                fait_quast();
                break;
 
 
 
 
     /* We have an undefined quast */
     case Nil : init_quast();
                creer_quast_value();
                fait_quast();
                i++; break;
 
 
 
 
     /* This should not happen any more */
     case Form: pips_internal_error("Form case call");
                break;
 
     /* This case should not happen any more */
     case Div:  pips_internal_error("Div case call");
                break;
 
     /* This case should not happen any more */
     case Val:  pips_internal_error("Val case call");
                break;
 
 
     default: pips_internal_error("Undefined kind of quast ");
 
        }
        
    return(i);
}

References creer_predicat(), creer_Psysteme(), creer_quast_value(), creer_true_quast(), D, Div, DIVIDE_OPERATOR_NAME, ecrit_coeff1(), ecrit_liste_vecteur(), ecrit_une_var(), ecrit_une_var_neg(), Entier, expression_act, fait_quast(), fait_quast_value(), S::flags, Form, If, init_liste_vecteur(), init_quast(), init_vecteur(), int_to_expression(), List, make_op_exp(), New, Nil, S::param1, S::param2, pips_internal_error, sol_pgcd(), sol_ppcm(), sol_space, and Val.

Referenced by pip_solve(), and pip_solve_min_with_big().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_to_tableau()

Tableau* sc_to_tableau	(	Psysteme	in_ps,
		int	nb_var
	)

==========================================================================

Tableau* sc_to_tableau( (Psysteme) in_ps, (int) nb_var ) AL 6/12/93 Allocates a new Tableau and fill it with in_ps. nb_var represents the number of variables in the systeme in_ps. The input systeme base should be ordered: nb_var first, constant term, then the parameters. If nb_var = 0, there is no variables : the order is then parameters first, then constant.

Let's define h, w, and n according to tab_get in Pip/tab.c

If nb_var = 0, put parameter before constant

Definition at line 629 of file pip_interface.c.

{
        Tableau         *p;
        int             h, w, n;
        int             i;
        Pcontrainte     cont;
 
        debug(7, "sc_to_tableau", "Input Psysteme :\n");
        if (get_debug_level()>7) fprint_psysteme(stderr, in_ps);
 
        /* Let's define h, w, and n according to tab_get in Pip/tab.c*/
        h = 2*in_ps->nb_eq + in_ps->nb_ineq;
        w = in_ps->dimension + 1;
        n = nb_var;
 
 
        p = tab_alloc(h, w, n);
        if (in_ps == NULL) return NULL;
 
        /* If nb_var = 0, put parameter before constant */
        if (nb_var == 0) nb_var = vect_size(in_ps->base);
 
        i = n;
        for( cont = in_ps->egalites; cont != NULL; cont = cont->succ) {
                p->row[i].flags = Unknown;
                new_ecrit_ligne(cont->vecteur, in_ps->base, nb_var, 
                                        p->row[i].objet.val);
                i++;
 
 
                p->row[i].flags = Unknown;
                new_ecrit_ligne(vect_multiply(vect_dup(cont->vecteur),
                                              VALUE_MONE), 
                                in_ps->base, nb_var, p->row[i].objet.val);
                i++;
        }
        for( cont = in_ps->inegalites; cont != NULL; cont = cont->succ) {
                p->row[i].flags = Unknown;
                new_ecrit_ligne(cont->vecteur, in_ps->base, nb_var,
                                   p->row[i].objet.val);
                i++;
        }
 
        debug(7, "sc_to_tableau", "Output Tableau :\n");
        if (get_debug_level()>6) tab_display(p, stderr);
        return((Tableau *) p);
}

References debug(), L::flags, fprint_psysteme(), get_debug_level(), new_ecrit_ligne(), L::objet, T::row, Scontrainte::succ, tab_alloc(), tab_display(), Unknown, L::val, VALUE_MONE, vect_dup(), vect_multiply(), vect_size(), and Scontrainte::vecteur.

Referenced by pip_solve(), and pip_solve_min_with_big().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

base_ref

Pbase base_ref

Base of the unknowns.

Definition at line 79 of file pip_interface.c.

base_var_ref

Pbase base_var_ref

Name : pip_interface.c Package : paf-util Author : A.

Tag for MIN or MAX resolution.

Leservot Date : 01 12 1993 Historic : Documents: Comments : Functions to call directly PIP from C3 and get results back in a newgen data (quast). Ansi includes
Newgen includes
C3 includes
Pips includes
Global variables

Definition at line 79 of file pip_interface.c.

expression_act

expression expression_act

extern

Definition at line 94 of file solpip.c.

Referenced by ajoute_constante(), ajoute_new_var(), ecrit_liste_vecteur(), ecrit_une_var(), ecrit_une_var_neg(), init_quast(), init_vecteur(), and rational_sol_edit().

ind_min_max

int ind_min_max

Definition at line 80 of file pip_interface.c.

old_base

Pbase old_base

Base of the parameters.

Definition at line 79 of file pip_interface.c.

old_base_var

Pbase old_base_var

Base of the unknowns.

Definition at line 79 of file pip_interface.c.

quast_act

quast quast_act

extern

Global variables

Definition at line 101 of file pip.c.

Referenced by creer_true_quast(), ecrit_resultat(), fait_quast(), pip_solve(), and pip_solve_min_with_big().

sol_space

struct S sol_space[]

extern

Definition at line 33 of file sol.c.

Referenced by integer_sol_edit(), is_not_Nil(), new_sol_edit(), rational_sol_edit(), sol_alloc(), and sol_edit().

vect_for_sort

Pvecteur vect_for_sort

Definition at line 104 of file pip_interface.c.