polyedre.h File Reference

#include "ray_dte.h"
#include "sg.h"

Include dependency graph for polyedre.h:

Go to the source code of this file.

Functions
Psysteme	sc_enveloppe_chernikova_ofl_ctrl (Psysteme, Psysteme, int)
	Warning! Do not modify this file that is automatically generated!
Psysteme	sc_enveloppe_chernikova (Psysteme, Psysteme)
Psysteme	elementary_convex_union (Psysteme, Psysteme)
	implements FC basic idea of simple fast cases.
Psysteme	sc_cute_convex_hull (Psysteme, Psysteme)
	returns s1 v s2.
void	catch_alarm_SC_CONVEX_HULL (int)
Ptsg	sc_to_sg_chernikova (Psysteme)
	Fonction de conversion d'un systeme lineaire a un systeme generateur par chenikova.
Psysteme	sg_to_sc_chernikova (Ptsg)
	Fonction de conversion d'un systeme generateur a un systeme lineaire.
Psysteme	sc_convex_hull (Psysteme, Psysteme)
Variables
boolean	SC_CONVEX_HULL_timeout
	chernikova.c

---

Function Documentation

void catch_alarm_SC_CONVEX_HULL

(

int

)

Psysteme elementary_convex_union	(	Psysteme	s1,
		Psysteme	s2
	)

implements FC basic idea of simple fast cases.

.. returns s1 v s2. s1 and s2 are not touched. The bases should be minimum for best efficiency! otherwise useless columns are allocated and computed. a common base is rebuilt in actual_convex_union. other fast cases may be added?

Parameters:

	s1	1
	s2	2

Definition at line 169 of file sc_enveloppe.c.

References actual_convex_union(), b, b1, b2, base_rm, base_union(), s, sc_base, sc_dup(), sc_empty(), sc_empty_p(), sc_rn(), sc_rn_p(), and vect_common_variables_p().

Referenced by sc_cute_convex_hull().

{
  boolean
    b1 = sc_empty_p(s1),
    b2 = sc_empty_p(s2);
    
  if (b1 && b2)
    return sc_empty(base_union(sc_base(s1), sc_base(s2)));

  if (b1) {
    Psysteme s = sc_dup(s2);
    Pbase b = base_union(sc_base(s1), sc_base(s2));
    base_rm(sc_base(s));
    sc_base(s) = b;
    return s;
  }
  
  if (b2) {
    Psysteme s = sc_dup(s1);
    Pbase b = base_union(sc_base(s1), sc_base(s2));
    base_rm(sc_base(s));
    sc_base(s) = b;
    return s;
  }
  
  if (sc_rn_p(s1) || sc_rn_p(s2) || 
      !vect_common_variables_p(sc_base(s1), sc_base(s2)))
    return sc_rn(base_union(sc_base(s1), sc_base(s2)));

  /*
  if (sc_dimension(s1)==1 && sc_dimension(s2)==1 && 
      sc_base(s1)->var == sc_base(s2)->var)
  {
    // fast computation...
  }
  */

  return actual_convex_union(s1, s2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme sc_convex_hull	(	Psysteme	,
		Psysteme
	)

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

need to install sc before to run, because of Production/Include/sc.h ifscprint(4) { char * filename; char * label; if print to stderr fprintf(stderr, "Timeout [sc_convex_hull] considering:\n"); sc_default_dump(sc1) sc_default_dump(sc2) filename = "convex_hull_fail_sc_dump.out"; label = "LABEL - Timeout with sc_convex_hull considering: *** * *** SC "; sc_default_dump_to_file(sc1,label,1,filename); label = " *** * *** SC "; sc_default_dump_to_file(sc2,label,2,filename); }

comme on il ne faut pas que les structures irisa apparaissent dans le fichier polyedre.h, une sous-routine renvoyant un polyhedron n'est pas envisageable. Le code est duplique

Tri des contraintes de A1->Ray et A2->Ray, pour former l'union de ces contraintes dans un meme format Line , Ray , vertex

end TRY

Definition at line 558 of file chernikova.c.

References any_exception_error, assert, base_dup(), CATCH, catch_alarm_SC_CONVEX_HULL(), contrainte_make(), cp, FALSE, fprintf(), ifscdebug, matrix_to_sc(), MAX_NB_RAYS, my_Matrix_Free(), my_Polyhedron_Free(), NULL, RETHROW, SC_CONVEX_HULL_TIMEOUT, SC_CONVEX_HULL_timeout, sc_default_dump(), sc_dimension, sc_make(), sc_new(), sc_normalize(), sc_rm(), sc_to_matrix(), SC_UNDEFINED_P, TCST, TRY, UNCATCH, VALUE_ONE, vect_new(), and vect_size().

Referenced by main(), and sc_enveloppe_chernikova_ofl_ctrl().

{
    int nbrows1 = 0;
    int nbcolumns1 = 0;
    int nbrows2 = 0;
    int nbcolumns2 = 0;

    /* Automatic variables read in a CATCH block need to be declared volatile as
     * specified by the documentation*/
    Matrix * volatile a1 = NULL;
    Matrix * volatile a2 = NULL;
    Polyhedron * volatile A1 = NULL;
    Polyhedron * volatile A2 = NULL;
    Matrix * volatile a = NULL;
    Psysteme volatile sc = NULL;
    Polyhedron * volatile A = NULL;

    unsigned int i1, i2;
    int j;
    int Dimension,cp;

    CATCH(any_exception_error)
    {

      if (a) my_Matrix_Free(&a);
      if (a1) my_Matrix_Free(&a1);
      if (a2) my_Matrix_Free(&a2);
      if (A) my_Polyhedron_Free(&A);
      if (A1) my_Polyhedron_Free(&A1);
      if (A2) my_Polyhedron_Free(&A2);
      if (sc) sc_rm(sc);
      
      alarm(0);//clear the alarm. 
      //There's maybe exceptions rethrown by polylib. 
      //So clear alarm in catch_alarm_sc_convex_hull is not enough
      
      if (SC_CONVEX_HULL_timeout) {

        SC_CONVEX_HULL_timeout = FALSE;

        //fprintf(stderr,"\n *** * *** Timeout from polyedre/chernikova : sc_convex_hull !!! \n");
        
        //We can change to print to stderr by using sc_default_dump(sc). duong

        /* need to install sc before to run, because of Production/Include/sc.h
        ifscprint(4) {
        char * filename;
        char * label;
          // if  print to stderr
          //fprintf(stderr, "Timeout [sc_convex_hull] considering:\n");
          //sc_default_dump(sc1) 
          //sc_default_dump(sc2)          
          filename = "convex_hull_fail_sc_dump.out";
          label = "LABEL - Timeout with sc_convex_hull considering: *** * *** SC ";
          sc_default_dump_to_file(sc1,label,1,filename);
          label = "                                                 *** * *** SC ";
          sc_default_dump_to_file(sc2,label,2,filename);        
        }
        */
      }

      //fprintf(stderr,"\nThis is an exception rethrown from sc_convex_hull(): \n ");
      RETHROW();
    }
    TRY 
    {

    assert(!SC_UNDEFINED_P(sc1) && (sc_dimension(sc1) != 0));
    assert(!SC_UNDEFINED_P(sc2) && (sc_dimension(sc2) != 0));

   

    //start the alarm
    signal(SIGALRM, catch_alarm_SC_CONVEX_HULL);   
    alarm(SC_CONVEX_HULL_TIMEOUT);

    ifscdebug(7) {
        fprintf(stderr, "[sc_convex_hull] considering:\n");
        sc_default_dump(sc1);
        sc_default_dump(sc2);
    }

    /* comme on il ne faut pas que les structures irisa 
       apparaissent dans le fichier polyedre.h, une sous-routine 
       renvoyant un polyhedron n'est pas envisageable.
       Le code est duplique */

    nbrows1 = sc1->nb_eq + sc1->nb_ineq + 1;
    nbcolumns1 = sc1->dimension +2;
    a1 = Matrix_Alloc(nbrows1, nbcolumns1);
    sc_to_matrix(sc1,a1);

    nbrows2 = sc2->nb_eq + sc2->nb_ineq + 1;
    nbcolumns2 = sc2->dimension +2;
    a2 = Matrix_Alloc(nbrows2, nbcolumns2);
    sc_to_matrix(sc2,a2);
   
    ifscdebug(8) {
        fprintf(stderr, "[sc_convex_hull]\na1 =");
        Matrix_Print(stderr, "%4d",a1);
        fprintf(stderr, "\na2 =");
        Matrix_Print(stderr, "%4d",a2);
    }

    A1 = Constraints2Polyhedron(a1, MAX_NB_RAYS);
   
    my_Matrix_Free(&a1); 

    A2 = Constraints2Polyhedron(a2, MAX_NB_RAYS);
      
    my_Matrix_Free(&a2);

    ifscdebug(8) {
        fprintf(stderr, "[sc_convex_hull]\nA1 (%p %p)=", A1, a1);
        Polyhedron_Print(stderr, "%4d",A1);
        fprintf(stderr, "\nA2 (%p %p) =", A2, a2);
        Polyhedron_Print(stderr, "%4d",A2);
    }
    
    sc = sc_new();
    sc->base = base_dup(sc1->base);
    //replace base_dup, which changes the pointer given as parameter
    sc->dimension = vect_size(sc->base);

    if (A1->NbRays == 0) {
        a= Polyhedron2Constraints(A2); 
    } else  if (A2->NbRays == 0) {
        a= Polyhedron2Constraints(A1); 
    } else {
        int i1p;
        int cpp;

        Dimension = A1->Dimension+2;
        a = Matrix_Alloc(A1->NbRays + A2->NbRays,Dimension);

        /* Tri des contraintes de A1->Ray et A2->Ray, pour former 
           l'union de ces contraintes dans un meme format 
           Line , Ray , vertex */
        cp = 0;
        i1 = 0;
        i2 = 0;
        while (i1 < A1->NbRays && A1->Ray[i1][0] ==0) {
            for (j=0; j < Dimension ; j++)
                a->p[cp][j] = A1->Ray[i1][j]; 
            cp++; i1++; 
        }

        while (i2 < A2->NbRays && A2->Ray[i2][0] ==0) {
            for (j=0 ; j < Dimension ; j++) 
                a->p[cp][j] = A2->Ray[i2][j];
            cp++; i2++;
        }

        i1p = i1;
        cpp = cp;
        while (i1 < A1->NbRays && A1->Ray[i1][0] ==1 
               && A1->Ray[i1][Dimension-1]==0) {
            for (j=0; j < Dimension ; j++) 
                a->p[cp][j] = A1->Ray[i1][j]; 
            cp++; i1++; 
        }

        while (i2 < A2->NbRays && A2->Ray[i2][0] == 1 
               && A2->Ray[i2][Dimension-1]==0) {
            for (j=0; j < Dimension ; j++) 
                a->p[cp][j] = A2->Ray[i2][j]; 
            cp++; i2++;
        }

        i1p = i1;
        cpp = cp;
        while (i1 < A1->NbRays && A1->Ray[i1][0] == 1 
               && A1->Ray[i1][Dimension-1]!= 0) {
            for (j=0; j < Dimension ; j++)  
                a->p[cp][j] = A1->Ray[i1][j]; 
            cp++; i1++; 
        }

        while (i2 < A2->NbRays && A2->Ray[i2][0] == 1 
               && A2->Ray[i2][Dimension-1]!=0) {
            for (j=0; j < Dimension ; j++)  
                a->p[cp][j] = A2->Ray[i2][j]; 
            cp++;  i2++;
        }
  
        my_Polyhedron_Free(&A1);
        my_Polyhedron_Free(&A2);
        
        A = Rays2Polyhedron(a, MAX_NB_RAYS);
        my_Matrix_Free(&a);

        a = Polyhedron2Constraints(A);    
        my_Polyhedron_Free(&A);
    }

    matrix_to_sc(a,sc);
    my_Matrix_Free(&a);

    sc = sc_normalize(sc);

    if (sc == NULL) {
        Pcontrainte pc = contrainte_make(vect_new(TCST, VALUE_ONE));
        sc = sc_make(pc, CONTRAINTE_UNDEFINED);
        sc->base = base_dup(sc1->base);
        //replace base_dup, which changes the pointer given as parameter
        sc->dimension = vect_size(sc->base);
    }

    } /* end TRY */
    
    alarm(0); //clear the alarm

    UNCATCH(any_exception_error);

    return sc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme sc_cute_convex_hull	(	Psysteme	is1,
		Psysteme	is2
	)

returns s1 v s2.

initial systems are not changed.

v convex union u union n intersection T orthogonality

(1) CA:

P1 v P2 = (P n X1) v (P n X2) = let P = P' n P'' so that P' T X1 and P' T X2 and P' T P'' built by transitive closure, then P1 v P2 = (P' n (P'' n X1)) v (P' n (P'' n X2)) = P' n ((P'' n X1) v (P'' n X2))

Proof by considering generating systems: Def: A T B <=> var(A) n var(B) = 0 Prop: A n B if A T B Let A = (x,v,l), B = (y,w,m) A n B = { z | z = (x) + (v) d + (l) e + (0) f (0) + (0) + (0) (I) and z = (0) + (0) g + (0) h + (I) f' (y) + (w) + (m) (0) with >0, >0, =1, =1, d>0, g>0 } we can always find f and f' equals to the other part (by extension) so A n B = { z | z = (x 0) + (v 0) d + (l 0) e (0 y) (0 w) g (0 m) h with d g constraints... } It is a convex : ((xi) , (v 0), (l 0)) (yj)ij, (0 w), (0 m) we just need to prove that Cmn == Cg defined as (x 0) == (xi) with >0 and = 1 (0 y) (yj)ij . Cg in a convex. . Cg Cmn since ((xi)\(yj) ij) in Cmn with = i, = j . Cmn Cg by chosing = , which >0 and = 1 Prop: A T B and A T C => A T (B v C) and A T (B n C) Theo: A T B and A T C => (A n B) v (A n C) = A n (B v C) compute both generating systems with above props. they are equal.

(2) FI:

perform exact projections of common equalities. no proof at the time. It looks ok anyway.

(3) FC:

base(P) n base(Q) = 0 => P u Q = Rn and some other very basic simplifications... which are not really interesting if no decomposition is performed?

on overflows FI suggested.

1/ we want to compute : (A n B1) u (A n B2) 2/ we chose to approximate it as : (A n B1) v (A n B2) 3/ we try Corinne's factorization with transitive closure A' n ((A'' n B1) v (A'' n B2)) 4/ on overflow, we can try A n (B1 v B2) // NOT IMPLEMENTED YET 5/ if we have one more overflow, then A looks good as an approximation.

CA: extract common disjoint part.

FI: in sc_common_projection_convex_hull note that equalities are not that big a burden to chernikova?

fast sc_append

usually we use V (convex hull) as a U (set union) approximation. as we have : (A n B1) U (A n B2) A the common part of both systems is an approximation of the union! sc_rn is returned on overflows (and some other case). I don't think that the result is improved apart when actual overflow occurs. FC/CA.

dead. either rm or moved as sc.

better compatibility with previous version, as the convex union normalizes the system and removes redundancy, what is not done if part of the system is separated. Other calls may be considered here?

ok, it will look better.

misleading... not really projected. { x==y, y==3 } => { x==3, y==3 }

sc, su: fast union of disjoint.

regenerate the expected base.

Parameters:

	is1	s1
	is2	s2

Definition at line 367 of file sc_enveloppe.c.

References base_rm, base_union(), elementary_convex_union(), extract_common_syst(), linear_number_of_exception_thrown, NULL, s1, sc_base, sc_dimension, sc_dup(), sc_extract_exact_common_equalities(), sc_fix(), sc_fusion(), sc_project_very_simple_equalities(), sc_rm(), sc_rn(), sc_transform_ineg_in_eg(), transitive_closure_from_two_bases(), and vect_size().

Referenced by cute_convex_union().

{
  Psysteme s1, s2, sc, stc, su, scsaved;
  int current_overflow_count;

  s1 = sc_dup(is1);
  s2 = sc_dup(is2);

  /* CA: extract common disjoint part.
   */
  sc = extract_common_syst(s1, s2);
  scsaved = sc_dup(sc);
  stc = transitive_closure_from_two_bases(sc, s1->base, s2->base);

  /* FI: in sc_common_projection_convex_hull
     note that equalities are not that big a burden to chernikova?
   */
  sc_extract_exact_common_equalities(stc, sc, s1, s2);

  /* fast sc_append */
  s1 = sc_fusion(s1, sc_dup(stc));
  sc_fix(s1);

  s2 = sc_fusion(s2, stc);
  sc_fix(s2);

  stc = NULL;

  current_overflow_count = linear_number_of_exception_thrown;

  su = elementary_convex_union(s1, s2);
  
  /* usually we use V (convex hull) as a U (set union) approximation.
   * as we have : (A n B1) U (A n B2) \in A
   * the common part of both systems is an approximation of the union!
   * sc_rn is returned on overflows (and some other case).
   * I don't think that the result is improved apart 
   * when actual overflow occurs. FC/CA.
   */
  if (current_overflow_count!=linear_number_of_exception_thrown)
  {
    if (su) sc_rm(su), su = NULL;
    if (sc) sc_rm(sc), sc = NULL;
    sc = scsaved;
  }
  else
  {
    sc_rm(scsaved);
  }

  scsaved = NULL; /* dead. either rm or moved as sc. */
  sc_rm(s1); 
  sc_rm(s2);

  /* better compatibility with previous version, as the convex union
   * normalizes the system and removes redundancy, what is not done
   * if part of the system is separated. Other calls may be considered here?
   */
  sc_transform_ineg_in_eg(sc); /* ok, it will look better. */
  /* misleading... not really projected. { x==y, y==3 } => { x==3, y==3 } */
  sc_project_very_simple_equalities(sc);

  /* sc, su: fast union of disjoint. */
  sc = sc_fusion(sc, su);

  /* regenerate the expected base. */
  if (sc) 
  {
    sc_fix(sc);
    if (sc_base(sc)) base_rm(sc_base(sc));
  }
  else
  {
      sc = sc_rn(NULL);
  }
  sc_base(sc) = base_union(sc_base(is1), sc_base(is2));
  sc_dimension(sc) = vect_size(sc_base(sc));
  
  return sc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme sc_enveloppe_chernikova	(	Psysteme	,
		Psysteme
	)

Definition at line 125 of file sc_enveloppe.c.

References OFL_CTRL, and sc_enveloppe_chernikova_ofl_ctrl().

Referenced by actual_convex_union(), and dependence_cone_positive().

{
  return sc_enveloppe_chernikova_ofl_ctrl((s1), (s2), OFL_CTRL);
} 

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme sc_enveloppe_chernikova_ofl_ctrl	(	Psysteme	s1,
		Psysteme	s2,
		int	ofl_ctrl
	)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/polyedre/polyedre-local.h instead, to add your own modifications. header file built by cprotopackage sur les polyedres poly Malik Imadache, Corinne Ancourt, Neil Butler, Francois Irigoin

Modifications:

• declaration de Ppoly et Spoly utilisant Psysteme au lieu de struct Ssysteme * (FI, 3/1/90)obsolete (not maintained)macro d'acces aux champs et sous-champs d'un polyedre, de son systeme generateur sg et de son systeme de contraintes scsc_enveloppe.c

Warning! Do not modify this file that is automatically generated!

Ce module est range dans le package polyedre bien qu'il soit utilisable en n'utilisant que des systemes lineaires (package sc) parce qu'il utilise lui-meme des routines sur les polyedres.

Francois Irigoin, Janvier 1990 Corinne Ancourt, Fabien Coelho from time to time (1999/2000)Psysteme sc_enveloppe_chernikova_ofl_ctrl(Psysteme s1, s2, int ofl_ctrl) input : output : modifies : s1 and s2 are NOT modified. comment : s1 and s2 must have a basis.

s = enveloppe(s1, s2); return s;

calcul d'une representation par systeme lineaire de l'enveloppe convexe des polyedres definis par les systemes lineaires s1 et s2

mem_spy_begin();

PLEASE do not remove this warning.

BC 24/07/95

calcul de l'enveloppe convexe

printf("systeme final \n"); sc_dump(s);

mem_spy_end("sc_enveloppe_chernikova_ofl_ctrl");

Parameters:

	s1	1
	s2	2
	ofl_ctrl	fl_ctrl

Definition at line 64 of file sc_enveloppe.c.

References assert, base_dup(), CATCH, FALSE, fprintf(), FWD_OFL_CTRL, OFL_CTRL, overflow_error, s, sc_base, sc_convex_hull(), sc_dimension, sc_dup(), sc_elim_redond, sc_empty(), sc_empty_p(), sc_faisabilite_ofl, sc_rn(), sc_rn_p(), SC_RN_P, SC_UNDEFINED, SC_UNDEFINED_P, timeout_error, TRUE, and UNCATCH.

Referenced by sc_enveloppe_chernikova().

{
    Psysteme s = SC_UNDEFINED;
    boolean catch_performed = FALSE;
    /* mem_spy_begin(); */

    assert(!SC_UNDEFINED_P(s1) && !SC_UNDEFINED_P(s2));

    switch (ofl_ctrl) 
    {
    case OFL_CTRL :
        ofl_ctrl = FWD_OFL_CTRL;
        catch_performed = TRUE;
        CATCH(overflow_error|timeout_error) {
          //CATCH(overflow_error) {
            /* 
             *   PLEASE do not remove this warning.
             *
             *   BC 24/07/95
             */
            fprintf(stderr, "[sc_enveloppe_chernikova_ofl_ctrl] "
                    "arithmetic error occured\n" );
            s = sc_rn(base_dup(sc_base(s1)));
            break;
        }               
    default: {
    
            if (SC_RN_P(s2) || sc_rn_p(s2) || sc_dimension(s2)==0
                || sc_empty_p(s1) || !sc_faisabilite_ofl(s1)) 
            {
                Psysteme sc2 = sc_dup(s2);
                sc2 = sc_elim_redond(sc2);
                s = SC_UNDEFINED_P(sc2)? sc_empty(base_dup(sc_base(s2))): 
                    sc2;
            }
            else 
                if (SC_RN_P(s1) ||sc_rn_p(s1) || sc_dimension(s1)==0   
                    || sc_empty_p(s2) || !sc_faisabilite_ofl(s2)) 
                {
                    Psysteme sc1 = sc_dup(s1);
                    sc1 = sc_elim_redond(sc1);
                    s = SC_UNDEFINED_P(sc1)? 
                        sc_empty(base_dup(sc_base(s1))): sc1;
                }
                else 
                {
                    /* calcul de l'enveloppe convexe */
                    s = sc_convex_hull(s1,s2);
                    /* printf("systeme final \n"); sc_dump(s);  */
                }
            if (catch_performed)
                UNCATCH(overflow_error|timeout_error);
        }
    }
    /* mem_spy_end("sc_enveloppe_chernikova_ofl_ctrl"); */
    return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ptsg sc_to_sg_chernikova

(

Psysteme

)

Fonction de conversion d'un systeme lineaire a un systeme generateur par chenikova.

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

end TRY

Definition at line 450 of file chernikova.c.

References any_exception_error, assert, base_dup(), CATCH, MAX_NB_RAYS, my_Matrix_Free(), my_Polyhedron_Free(), NULL, polyhedron_to_sg(), RETHROW, sc_dimension, sc_to_matrix(), SC_UNDEFINED_P, sg, sg_new(), sg_rm(), TRY, and UNCATCH.

Referenced by dependence_cone_positive(), main(), and unimodular().

{
    /* Automatic variables read in a CATCH block need to be declared volatile as
     * specified by the documentation*/
    Polyhedron * volatile A = NULL;
    Matrix * volatile a = NULL;
    Ptsg volatile sg = NULL;

    int nbrows = 0;
    int nbcolumns = 0;

    CATCH(any_exception_error)
    {
      if (A) my_Polyhedron_Free(&A);
      if (a) my_Matrix_Free(&a);
      if (sg) sg_rm(sg);

      RETHROW();
    }
    TRY 
    {
      assert(!SC_UNDEFINED_P(sc) && (sc_dimension(sc) != 0));

      sg = sg_new();
      nbrows = sc->nb_eq + sc->nb_ineq + 1;
      nbcolumns = sc->dimension +2;
      sg->base = base_dup(sc->base);
      //replace base_dup, which changes the pointer given as parameter
      a = Matrix_Alloc(nbrows, nbcolumns);
      sc_to_matrix(sc,a);
      
      A = Constraints2Polyhedron(a, MAX_NB_RAYS);
      my_Matrix_Free(&a);
      
      polyhedron_to_sg(A,sg);
      my_Polyhedron_Free(&A);
    } /* end TRY */

    UNCATCH(any_exception_error);

    return sg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Psysteme sg_to_sc_chernikova

(

Ptsg

sg

)

Fonction de conversion d'un systeme generateur a un systeme lineaire.

par chernikova

Automatic variables read in a CATCH block need to be declared volatile as specified by the documentation

end TRY

Parameters:

sg

g

Definition at line 496 of file chernikova.c.

References any_exception_error, base_dimension, base_dup(), CATCH, contrainte_make(), matrix_to_sc(), MAX_NB_RAYS, my_Matrix_Free(), my_Polyhedron_Free(), NULL, RETHROW, sc_make(), sc_new(), sc_normalize(), sc_rm(), sg_nbre_droites, sg_nbre_rayons, sg_nbre_sommets, sg_to_polyhedron(), TCST, TRY, UNCATCH, VALUE_ONE, vect_new(), and vect_size().

Referenced by main(), prettyprint_dependence_graph(), prettyprint_dependence_graph_view(), and whole_loop_parallelize().

{
    int nbrows = sg_nbre_droites(sg)+ sg_nbre_rayons(sg)+sg_nbre_sommets(sg);
    int nbcolumns = base_dimension(sg->base)+2;
    /* Automatic variables read in a CATCH block need to be declared volatile as
     * specified by the documentation*/
    Matrix * volatile a = NULL;
    Psysteme volatile sc = NULL;
    Polyhedron * volatile A = NULL;

    CATCH(any_exception_error)
    {
      if (sc) sc_rm(sc);
      if (a) my_Matrix_Free(&a);
      if (A) my_Polyhedron_Free(&A);

      RETHROW();
    }
    TRY
    {

    sc = sc_new();
    sc->base = base_dup(sg->base);
    //replace base_dup, which changes the pointer given as parameter
    sc->dimension = vect_size(sc->base);

    if (sg_nbre_droites(sg)+sg_nbre_rayons(sg)+sg_nbre_sommets(sg)) {

        a = Matrix_Alloc(nbrows, nbcolumns);
        sg_to_polyhedron(sg,a);  
   
        A = Rays2Polyhedron(a, MAX_NB_RAYS);
        my_Matrix_Free(&a); 

        a = Polyhedron2Constraints(A);
        my_Polyhedron_Free(&A);

        matrix_to_sc(a,sc);
        my_Matrix_Free(&a);

        sc=sc_normalize(sc);

        if (sc == NULL) {
            Pcontrainte pc = contrainte_make(vect_new(TCST, VALUE_ONE));
            sc = sc_make(pc, CONTRAINTE_UNDEFINED);
            sc->base = base_dup(sg->base);
            //replace base_dup, which changes the pointer given as parameter
            sc->dimension = vect_size(sc->base);        }

    }
    else {
        sc->egalites = contrainte_make(vect_new(TCST,VALUE_ONE));
        sc->nb_eq ++;
    }   
    } /* end TRY */

    UNCATCH(any_exception_error);

    return sc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

boolean SC_CONVEX_HULL_timeout

chernikova.c

Definition at line 71 of file chernikova.c.

Referenced by catch_alarm_SC_CONVEX_HULL(), and sc_convex_hull().