Return to drivers_for_input_planes.ads CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Schubert

Annotation of OpenXM_contrib/PHC/Ada/Schubert/drivers_for_input_planes.ads, Revision 1.1.1.1

1.1       maekawa     1: with text_io;                            use text_io;
                      2: with Brackets;                           use Brackets;
                      3: with Standard_Floating_Vectors;          use Standard_Floating_Vectors;
                      4: with Standard_Complex_VecMats;           use Standard_Complex_VecMats;
                      5:
                      6: package Drivers_for_Input_Planes is
                      7:
                      8: -- DESCRIPTION :
                      9: --   This package provides menu's to generate random and real input planes
                     10: --   for the three types of Pieri homotopies.
                     11: --   The open design of the package is due to its use in both the usual
                     12: --   as in the quantum Pieri homotopies.
                     13:
                     14: -- READING CO-DIMENSION CONDITIONS :
                     15:
                     16:   function Read_Codimensions ( m,p,q : natural ) return Bracket;
                     17:
                     18:   -- DESCRIPTION :
                     19:   --   Reads the vector of co-dimensions with a test whether these
                     20:   --   co-dimensions condition will lead to a finite number of solutions.
                     21:
                     22: -- PRIMITIVES :
                     23:
                     24:   function Random_Complex_Planes ( m,p : natural ) return VecMat;
                     25:   function Random_Real_Planes    ( m,p : natural ) return VecMat;
                     26:
                     27:   -- DESCRIPTION :
                     28:   --   Returns a vector of range 1..m*p with random complex/real m-planes,
                     29:   --   with the columns orthonormalized.
                     30:
                     31:   function Random_Complex_Planes ( m,p : natural; k : Bracket ) return VecMat;
                     32:   function Random_Real_Planes    ( m,p : natural; k : Bracket ) return VecMat;
                     33:
                     34:   -- DESCRIPTION :
                     35:   --   Returns a vector of the same range as k with random (m+1-k(i))-planes,
                     36:   --   with the columns orthonormalized.
                     37:
                     38:   function Random_Complex_Planes ( m,p,q : natural ) return VecMat;
                     39:   function Random_Real_Planes    ( m,p,q : natural ) return VecMat;
                     40:
                     41:   -- DESCRIPTION :
                     42:   --   Returns a vector of range 1..m*p+q*(m+p) with random complex or real
                     43:   --   m-planes, --   with the columns orthonormalized.
                     44:
                     45:   function Equidistant_Interpolation_Points ( n : natural ) return Vector;
                     46:
                     47:   -- DESCRIPTION :
                     48:   --   Generates n equidistant interpolation points in [-1,+1],
                     49:   --   starting at a random value.
                     50:
                     51:   function Read_Interpolation_Points ( n : natural ) return Vector;
                     52:
                     53:   -- DESCRIPTION :
                     54:   --   Reads n s-values from standard input.
                     55:
                     56:   function Osculating_Input_Planes ( m,p : natural ) return VecMat;
                     57:   function Osculating_Input_Planes ( m,p : natural; s : Vector ) return VecMat;
                     58:
                     59:   -- DESCRIPTION :
                     60:   --   Returns a vector of range 1..m*p with real m-planes osculating
                     61:   --   a rational normal curve, sampled at equidistant points in [-1,+1],
                     62:   --   or, if specified at the given s-values.
                     63:
                     64:   function Osculating_Input_Planes
                     65:              ( m,p : natural; k : Bracket ) return VecMat;
                     66:   function Osculating_Input_Planes
                     67:              ( m,p : natural; k : Bracket; s : Vector ) return VecMat;
                     68:
                     69:   -- DESCRIPTION :
                     70:   --   Returns a vector of the same range as k with real (m+1-k(i))-planes
                     71:   --   osculating a rational normal curve, sampled at equidistant points
                     72:   --   in [-1,+1], or, if specified at the given s-values.
                     73:
                     74:   function Osculating_Input_Planes ( m,p,q : natural ) return VecMat;
                     75:   function Osculating_Input_Planes
                     76:              ( m,p,q : natural; s : Vector ) return VecMat;
                     77:
                     78:   -- DESCRIPTION :
                     79:   --   Returns a vector of the range 1..m*p+q*(m+p) with real m-planes
                     80:   --   osculating a rational normal curve, sampled at equidistant points
                     81:   --   in [-1,+1], or, if specified at the given s-values.
                     82:
                     83:   function Read_Input_Planes ( m,p : natural ) return VecMat;
                     84:
                     85:   -- DESCRIPTION :
                     86:   --   Returns a vector of range 1..m*p with real m-planes retrieved from
                     87:   --   a file given by the user after calling this function.
                     88:   --   The matrices on return have their columns orthonormalized.
                     89:
                     90:   function Read_Input_Planes ( m,p : natural; k : Bracket ) return VecMat;
                     91:
                     92:   -- DESCRIPTION :
                     93:   --   Returns a vector of the same range as k with real (m+1-k(i))-planes
                     94:   --   retrieved from a file given by the user after calling this function.
                     95:   --   The matrices on return have their columns orthonormalized.
                     96:
                     97:   function Read_Input_Planes ( m,p,q : natural ) return VecMat;
                     98:
                     99:   -- DESCRIPTION :
                    100:   --   Returns a vector of range 1..m*p+q*(m+p) with real m-planes retrieved
                    101:   --   from a file given by the user after calling this function.
                    102:   --   The matrices on return have their columns orthonormalized.
                    103:
                    104: -- MAIN INTERACTIVE DRIVERS :
                    105:
                    106:   procedure Driver_for_Input_Planes
                    107:               ( file : in file_type; m,p : in natural; planes : out VecMat );
                    108:
                    109:   -- DESCRIPTION :
                    110:   --   Generates m-planes as input to the hypersurface Pieri algorithm.
                    111:
                    112:   -- ON ENTRY :
                    113:   --   file     to write output logistics on;
                    114:   --   m        dimension of the input planes, number of columns;
                    115:   --   p        dimension of the output planes, m+p = number of rows.
                    116:
                    117:   -- ON RETURN :
                    118:   --   planes   vector of range 1..m*p with m-planes in dimension m+p.
                    119:
                    120:   procedure Driver_for_Input_Planes
                    121:               ( file : in file_type; m,p : in natural; k : in Bracket;
                    122:                 planes : out VecMat );
                    123:
                    124:   -- DESCRIPTION :
                    125:   --   Generates m-planes as input to the general Pieri algorithm.
                    126:
                    127:   -- ON ENTRY :
                    128:   --   file     to write output logistics on;
                    129:   --   m        number of columns of the input planes is m+1-k(i);
                    130:   --   p        dimension of the output planes, m+p = number of rows;
                    131:   --   k        co-dimension conditions of the input planes.
                    132:
                    133:   -- ON RETURN :
                    134:   --   planes   vector of same range as k with (m+1-k(i))-planes in
                    135:   --            a space of dimension m+p.
                    136:
                    137:   procedure Driver_for_Input_Planes
                    138:               ( file : in file_type; m,p,q : in natural;
                    139:                 s : out Vector; planes : out VecMat );
                    140:
                    141:   -- DESCRIPTION :
                    142:   --   Generates m-planes as input to the quantum Pieri algorithm.
                    143:
                    144:   -- ON ENTRY :
                    145:   --   file     to write output logistics on;
                    146:   --   m        number of columns of the input planes is m+1-k(i);
                    147:   --   p        dimension of the output planes, m+p = number of rows;
                    148:   --   q        degree of the output maps.
                    149:
                    150:   -- ON RETURN :
                    151:   --   s        vector of range 1..m*p+q*(m+p) of interpolation points;
                    152:   --   planes   vector of range 1..m*p+q*(m+p) with m-planes in
                    153:   --            a space of dimension m+p, sampled at s-values.
                    154:
                    155: end Drivers_for_Input_Planes;