Return to floating_mixed_subdivisions.ads CVS log

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

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Stalift/floating_mixed_subdivisions.ads, Revision 1.1.1.1

1.1       maekawa     1: with Generic_Lists;
                      2: with Standard_Floating_Numbers;          use Standard_Floating_Numbers;
                      3: with Standard_Floating_Vectors;          use Standard_Floating_Vectors;
                      4: with Lists_of_Floating_Vectors;          use Lists_of_Floating_Vectors;
                      5: with Arrays_of_Floating_Vector_Lists;    use Arrays_of_Floating_Vector_Lists;
                      6:
                      7: package Floating_Mixed_Subdivisions is
                      8:
                      9: -- DESCRIPTION :
                     10: --   This package enables working with regular mixed subdivisions.
                     11:
                     12: -- DATA STRUCTURES :
                     13:
                     14:   type Mixed_Subdivision;              -- list of mixed cells
                     15:   type Link_to_Mixed_Subdivision is access Mixed_Subdivision;
                     16:
                     17:   type Mixed_Cell is record
                     18:     nor : Link_to_Vector;              -- inner normal to the facet
                     19:     pts : Link_to_Array_of_Lists;      -- points that span the cell
                     20:     sub : Link_to_Mixed_Subdivision;   -- subdivision of the cell
                     21:   end record;
                     22:
                     23:   package Lists_of_Mixed_Cells is new Generic_Lists(Mixed_Cell);
                     24:   type Mixed_Subdivision is new Lists_of_Mixed_Cells.List;
                     25:
                     26: -- CREATORS :
                     27:
                     28:   function Create ( pts : Array_of_Lists; nor : Vector; tol : double_float )
                     29:                   return Mixed_Cell;
                     30:   function Create ( pts : Array_of_Lists; nors : List; tol : double_float )
                     31:                   return Mixed_Subdivision;
                     32:
                     33:   -- DESCRIPTION :
                     34:   --   Creates the mixed cell(s) of those points whose inner product
                     35:   --   with the given normal(s) is minimal.
                     36:   --   The parameter tol is the tolerance on the precision.
                     37:
                     38:   function Create ( pts : Array_of_Lists; mixsub : Mixed_Subdivision;
                     39:                     tol : double_float ) return Mixed_Subdivision;
                     40:
                     41:   -- DESCRIPTION :
                     42:   --   Takes the normals of the cells in the given mixed subdivision
                     43:   --   and creates the mixed cells by selecting the points whose inner
                     44:   --   product with the normals are minimal.
                     45:
                     46:   procedure Update ( pts : in Array_of_Lists; nor : in Vector;
                     47:                      mixsub,mixsub_last : in out Mixed_Subdivision );
                     48:
                     49:   -- DESCRIPTION :
                     50:   --   Given a tuple of points and a normal, the mixed subdivision will
                     51:   --   be updated: either an existing cell will get additional points,
                     52:   --   if the normal already occurs in the subdivision, or otherwise,
                     53:   --   a new cell will be created and appended to the mixed subdivision.
                     54:
                     55: -- CONSTRUCTORS :
                     56:
                     57:   procedure Copy ( mic1 : in Mixed_Cell; mic2 : in out Mixed_Cell );
                     58:   procedure Copy ( mixsub1 : in Mixed_Subdivision;
                     59:                    mixsub2 : in out Mixed_Subdivision );
                     60:
                     61:   -- DESCRIPTION :
                     62:   --   Makes a deep copy of the cells and the subdivisions.
                     63:
                     64:   procedure Append_Diff ( first,last : in out Mixed_Subdivision;
                     65:                           mic : in Mixed_Cell );
                     66:
                     67:   -- DESCRIPTION :
                     68:   --   Appends a mixed cell to the list of cells first, where
                     69:   --   last points to the last element of the list first.
                     70:   --   The suffix _Diff means that only when the cell does not already
                     71:   --   belong to the list first, it will be appended.
                     72:
                     73:   procedure Concat_Diff ( first,last : in out Mixed_Subdivision;
                     74:                           mixsub : in Mixed_Subdivision );
                     75:
                     76:   -- DESCRIPTION :
                     77:   --   Concatenates all cells in mixsub to the list of cells first,
                     78:   --   last is a pointer to the last cell in first.
                     79:   --   The suffix _Diff means that only when those cells that do not already
                     80:   --   belong to the list first will be appended.
                     81:
                     82:   procedure Construct ( mixsub : in Mixed_Subdivision;
                     83:                         first : in out Mixed_Subdivision );
                     84:   procedure Construct_Diff ( mixsub : in Mixed_Subdivision;
                     85:                              first : in out Mixed_Subdivision );
                     86:
                     87:   -- DESCRIPTION :
                     88:   --   Constructs all cells in the mixed subdivision to the front of
                     89:   --   the list first.
                     90:   --   The suffix _Diff means that only when those cells that do not already
                     91:   --   belong to the list first will be constructed to first.
                     92:
                     93: -- SELECTORS :
                     94:
                     95:   function Equal ( mic1,mic2 : Mixed_Cell ) return boolean;
                     96:   function Equal ( mixsub1,mixsub2 : Mixed_Subdivision ) return boolean;
                     97:   function Equal ( mixsub1,mixsub2 : Link_to_Mixed_Subdivision )
                     98:                  return boolean;
                     99:
                    100:   -- DESCRIPTION :
                    101:   --   Returns true when two mixed cells and mixed subdivisions are equal.
                    102:
                    103:   function Is_In ( mixsub : Mixed_Subdivision; normal : Vector ) return boolean;
                    104:   function Is_In ( mixsub : Mixed_Subdivision; mic : Mixed_Cell )
                    105:                  return boolean;
                    106:
                    107:   -- DESCRIPTION :
                    108:   --   Returns true if normal or cell belongs to the mixed subdivision,
                    109:   --   otherwise false is returned.  When the whole mixed cell is given,
                    110:   --   then not only the normal, but also the points will be checked.
                    111:
                    112: -- DESTRUCTORS :
                    113:
                    114:   procedure Deep_Clear ( mic : in out Mixed_Cell );
                    115:   procedure Deep_Clear ( mixsub : in out Mixed_Subdivision );
                    116:   procedure Deep_Clear ( mixsub : in out Link_to_Mixed_Subdivision );
                    117:   procedure Shallow_Clear ( mic : in out Mixed_Cell );
                    118:   procedure Shallow_Clear ( mixsub : in out Mixed_Subdivision );
                    119:   procedure Shallow_Clear ( mixsub : in out Link_to_Mixed_Subdivision );
                    120:
                    121:   -- DESCRIPTION :
                    122:   --   The memory space allocated will be freed.
                    123:   --   A shallow clear only destroys the list structures,
                    124:   --   while with a deep clear, also the contents of the lists are freed.
                    125:
                    126: end Floating_Mixed_Subdivisions;