Return to integer_lifting_utilities.ads CVS log

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

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Stalift/integer_lifting_utilities.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 Lists_of_Integer_Vectors;           use Lists_of_Integer_Vectors;
                      5: with Integer_Mixed_Subdivisions;         use Integer_Mixed_Subdivisions;
                      6: with Arrays_of_Integer_Vector_Lists;     use Arrays_of_Integer_Vector_Lists;
                      7:
                      8: package Integer_Lifting_Utilities is
                      9:
                     10: -- DESCRIPTION :
                     11: --   This package provides some utilities for dealing with lifting functions.
                     12:
                     13:   function Adaptive_Lifting ( l : Array_of_Lists ) return Vector;
                     14:
                     15:   -- DESCRIPTION :
                     16:   --   Returns upper bounds for a random lifting, depending on the lengths
                     17:   --   of the lists in l.
                     18:
                     19: --  function Select_Subsystem ( p : Laur_Sys; mix : Vector; mic : Mixed_Cell )
                     20: --                            return Laur_Sys;
                     21:
                     22:   -- DESCRIPTION :
                     23:   --   Given a Laurent polynomial system and a mixed cell,
                     24:   --   the corresponding subsystem will be returned.
                     25:
                     26:   -- ON ENTRY :
                     27:   --   p          a Laurent polynomial system;
                     28:   --   mix        type of mixture: occurencies of the supports;
                     29:   --   mic        a mixed cell.
                     30:
                     31:   -- REQUIRED :
                     32:   --   The polynomials in p must be ordered according to the type of mixture.
                     33:
                     34:   function Perform_Lifting
                     35:                ( n : natural; l : List; p : Poly ) return Poly;
                     36:   function Perform_Lifting
                     37:                ( n : natural; mix : Vector; lifted : Array_of_Lists;
                     38:                  p : Laur_Sys ) return Laur_Sys;
                     39:
                     40:   -- DESCRIPTION :
                     41:   --   Construction of the polyhedral homotopy, given the lifted supports.
                     42:   --   The p will be lifted according to the lifted points, i.e. each
                     43:   --   monomial whose exponent vector corresponds to a vector in the
                     44:   --   lifted points (except for the last entry of course), will be
                     45:   --   extended with an additional unknown, with as exponent, the
                     46:   --   lifting value of that vector.
                     47:
                     48:   function Copy_Lifting ( lifted : List; pt : Link_to_Vector )
                     49:                         return Link_to_Vector;
                     50:
                     51:   -- DESCRIPTION :
                     52:   --   Searches the corresponding point in the list lifted and returns
                     53:   --   the lifted point.  If the corresponding point has not been found,
                     54:   --   then the original point pt will be returned.
                     55:
                     56:   function Copy_Lifting ( lifted,pts : List ) return List;
                     57:
                     58:   -- DESCRIPTION :
                     59:   --   Copies the lifting on the points lifted to the points in pts,
                     60:   --   i.e., each point in pts will get the same lifting as the corresponding
                     61:   --   lifted point in the list lifted.
                     62:
                     63:   procedure Search_Lifting ( l : in List; pt : in Vector;
                     64:                              found : out boolean; lif : out integer );
                     65:
                     66:   -- DESCRIPTION :
                     67:   --   Searches the lifting of the point in the lifted list l.
                     68:   --   If found, then lif equals the lifting, otherwise lif is meaningless.
                     69:
                     70:   function Search_and_Lift ( l : List; pt : Vector ) return Vector;
                     71:
                     72:   -- DESCRIPTION :
                     73:   --   Given a lifted list of points and a unlifted vector, the function
                     74:   --   either returns the corresponding lifted vector from the list, or
                     75:   --   the same point, when there is no lifted point in l whose projection
                     76:   --   equals the given point pt.
                     77:
                     78:   function Induced_Lifting ( mixsub : Mixed_Subdivision; k : natural;
                     79:                              pt : Vector ) return Vector;
                     80:   function Induced_Lifting
                     81:                ( n : natural; mix : Vector; points : Array_of_Lists;
                     82:                  mixsub : Mixed_Subdivision ) return Array_of_Lists;
                     83:
                     84:   -- DESCRIPTION :
                     85:   --   Given a mixed subdivision for a tuple of supports,
                     86:   --   then the lifted points will be returned as induced by the
                     87:   --   subdivision.   When points do not occur in the mixed subdivision,
                     88:   --   they will be lifted conservatively.
                     89:
                     90:   procedure Constant_Lifting
                     91:                ( l : in List; liftval : in natural;
                     92:                  lifted,lifted_last : in out List );
                     93:
                     94:   -- DESCRIPTION :
                     95:   --   Gives all points in l the constant lifting liftval,
                     96:   --   and appends them to the list lifted, where lifted_last is
                     97:   --   a pointer to the last element of lifted.
                     98:
                     99:   procedure Constant_Lifting
                    100:                ( al : in Array_of_Lists; liftval : in natural;
                    101:                  lifted,lifted_last : in out Array_of_Lists );
                    102:
                    103:   -- DESCRIPTION :
                    104:   --   Gives all points in al(i) the constant lifting liftval,
                    105:   --   and appends them to the lists lifted(i), where lifted_last(i) is
                    106:   --   a pointer to the last element of lifted(i).
                    107:
                    108:   function Conservative_Lifting
                    109:                ( mic : Mixed_Cell; k : natural; point : Vector ) return integer;
                    110:   function Conservative_Lifting
                    111:                ( mixsub : Mixed_Subdivision; k : natural; point : Vector )
                    112:                return integer;
                    113:
                    114:   -- DESCRIPTION :
                    115:   --   Returns the value of the conservative lifting function of the point
                    116:   --   to be considered w.r.t. the kth polytope.
                    117:
                    118:   -- REQUIRED :
                    119:   --   The given point must already be in the lifted space and its last
                    120:   --   coordinate must contain already a lower bound for the lifting value.
                    121:
                    122:   function Lower_Lifting ( mic : Mixed_Cell; k : natural; point : Vector )
                    123:                          return integer;
                    124:
                    125:   -- DESCRIPTION :
                    126:   --   Returns a lower bound on the lifting value.  In case that the point
                    127:   --   belongs to the kth component of the cell, the value zero is returned.
                    128:   --   Otherwise, the conservative lifting value of the point w.r.t. the
                    129:   --   cell is returned.
                    130:
                    131:   -- REQUIRED :
                    132:   --   The point must be already in lifted space.
                    133:
                    134:   function Lower_Lifting ( mixsub : Mixed_Subdivision; k : natural;
                    135:                            point : Vector ) return integer;
                    136:
                    137:   -- DESCRIPTION :
                    138:   --   Applies the lower lifting function to all cells in the subdivision.
                    139:   --   Stops when the lower bound equals the lifting value of the point
                    140:   --   equals the lifting of the point given on entry.
                    141:
                    142: end Integer_Lifting_Utilities;