Return to transforming_laurent_systems.ads CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Root_Counts / Implift

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Implift/transforming_laurent_systems.ads, Revision 1.1.1.1

1.1       maekawa     1: with Standard_Integer_Vectors;           use Standard_Integer_Vectors;
                      2: with Standard_Complex_Laur_Polys;        use Standard_Complex_Laur_Polys;
                      3: with Standard_Complex_Laur_Systems;      use Standard_Complex_Laur_Systems;
                      4: with Transformations;                    use Transformations;
                      5:
                      6: package Transforming_Laurent_Systems is
                      7:
                      8: -- DESCRIPTION :
                      9: --   This package offers some routines for transforming Laurent polynomials.
                     10:
                     11:   procedure Shift ( p : in out Poly );
                     12:   function  Shift ( p : Poly ) return Poly;
                     13:
                     14:   procedure Shift ( l : in out Laur_Sys );
                     15:   function  Shift ( l : Laur_Sys ) return Laur_Sys;
                     16:
                     17:   -- DESCRIPTION :
                     18:   --   Shifts the support of the polynomial so that the constant term
                     19:   --   belongs to p.
                     20:   --   This Shift does not change the term order in p!
                     21:
                     22:   procedure Transform ( t : in Transfo; p : in out Poly );
                     23:   function  Transform ( t : Transfo; p : Poly ) return Poly;
                     24:
                     25:   procedure Transform ( t : in Transfo; l : in out Laur_Sys );
                     26:   function  Transform ( t : Transfo; l : Laur_Sys ) return Laur_Sys;
                     27:
                     28:   -- DESCRIPTION : Application of the transformation t.
                     29:
                     30:   function Maximal_Support ( p : Poly; v : Vector ) return integer;
                     31:   function Maximal_Support ( p : Poly; v : Link_to_Vector ) return integer;
                     32:
                     33:   -- DESCRIPTION :
                     34:   --   Computes the value of the supporting function of the polynomial p,
                     35:   --   for the direction v.
                     36:
                     37:   procedure Face ( i,m : in integer; p : in out Poly );
                     38:   function  Face ( i,m : integer; p : Poly ) return Poly;
                     39:
                     40:   procedure Face ( i,m : in integer; l : in out Laur_Sys );
                     41:   function  Face ( i,m : integer; l : Laur_Sys ) return Laur_Sys;
                     42:
                     43:   -- DESCRIPTION :
                     44:   --   returns only the terms t for which deg(t,xi) = m.
                     45:
                     46:   procedure Face ( v : in Vector; m : in integer; p : in out Poly );
                     47:   function  Face ( v : Vector; m : integer; p : Poly ) return Poly;
                     48:
                     49:   procedure Face ( v,m : in Vector; l : in out Laur_Sys );
                     50:   function  Face ( v,m : Vector; l : Laur_Sys ) return Laur_Sys;
                     51:
                     52:   -- DESCRIPTION :
                     53:   --   Only the terms for which for the degrees d the following holds
                     54:   --    < d , v > = m, are left.
                     55:
                     56:   procedure Reduce ( i : in integer; p : in out Poly );
                     57:   function  Reduce ( i : integer; p : Poly ) return Poly;
                     58:
                     59:   procedure Reduce ( i : in integer; l : in out Laur_Sys );
                     60:   function  Reduce ( i : integer; l : Laur_Sys ) return Laur_Sys;
                     61:
                     62:   -- DESCRIPTION :
                     63:   --   The i-th component out of every monomial will be removed,
                     64:   --   so that the polynomials will have an unknown less.
                     65:
                     66:   procedure Insert ( i,d : in integer; p : in out Poly );
                     67:   function  Insert ( i,d : integer; p : Poly ) return Poly;
                     68:
                     69:   procedure Insert ( i,d : in integer; l : in out Laur_Sys );
                     70:   function  Insert ( i,d : integer; l : Laur_Sys ) return Laur_Sys;
                     71:
                     72:   -- DESCRIPTION :
                     73:   --   The i-th component of each monomial will be inserted,
                     74:   --   using the value d.
                     75:
                     76: end Transforming_Laurent_Systems;