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     ! 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;