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