Return to transformations.ads CVS log

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

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Implift/transformations.ads, Revision 1.1.1.1

1.1       maekawa     1: with Standard_Integer_Vectors;           use Standard_Integer_Vectors;
                      2: with Standard_Integer_VecVecs;           use Standard_Integer_VecVecs;
                      3: with Standard_Integer_Matrices;          use Standard_Integer_Matrices;
                      4: with Standard_Complex_Vectors;
                      5:
                      6: package Transformations is
                      7:
                      8: -- DESCRIPTION :
                      9: --   This package implements monomial transformations.
                     10:
                     11:   type Transfo is private;
                     12:
                     13: -- CONSTRUCTORS :
                     14:
                     15:   function Id ( n : natural ) return Transfo;
                     16:
                     17:   -- DESCRIPTION :
                     18:   --   Returns the identical transformation.
                     19:
                     20:   function Create ( v : Vector; i : integer ) return Transfo;
                     21:
                     22:   -- DESCRIPTION :
                     23:   --   returns a transformation T such that after w = Apply(T,v),
                     24:   --   there exists a j /= i: w(i) = 1 and w(j) = 0;
                     25:   --   if v(i) = 0, then the identity transformation will be returned;
                     26:   --   T is an isomorphism.
                     27:
                     28:   function Create ( v : VecVec ) return Transfo;
                     29:
                     30:   -- DESCRIPTION :
                     31:   --   returns a transformation T, where v(i) is the image of
                     32:   --   the i-th basis vector, for i in da'range.
                     33:
                     34:   function Create ( m : Matrix ) return Transfo;
                     35:
                     36:   -- DESCRIPTION :
                     37:   --   Returns the transformation defined by the matrix m.
                     38:   --   Apply(Create(m),v) = m*v.
                     39:
                     40:   function Rotate ( v : Vector; i : integer ) return Transfo;
                     41:   function Rotate ( v : Link_to_Vector; i : integer ) return Transfo;
                     42:
                     43:   -- DESCRIPTION :
                     44:   --   Returns a transformation T which will reduce v into e_i;
                     45:   --   if v(i) /= 0; T is an isomorphism.
                     46:
                     47:   function Build_Transfo ( v : Vector; i : integer ) return Transfo;
                     48:   function Build_Transfo ( v : Link_to_Vector; i : integer ) return Transfo;
                     49:
                     50:   -- DESCRIPTION :
                     51:   --   Returns a transformation T so that for all vectors x
                     52:   --   < x , v > = pv, after application of T on all x, the
                     53:   --   following holds: x(i) = pv / d, where d is the gcd of
                     54:   --   the components of v; T is an isomorphism.
                     55:
                     56: -- SELECTORS :
                     57:
                     58:   function Dimension ( t : Transfo ) return natural;
                     59:
                     60:   -- DESCRIPTION :
                     61:   --   Returns the dimension of the transformation.
                     62:
                     63:   function Sign ( t : Transfo ) return integer;
                     64:
                     65:   -- DESCRIPTION :
                     66:   --   Returns the determinant of the matrix representation of t,
                     67:   --   which is either +1 or -1.
                     68:
                     69: -- OPERATIONS :
                     70:
                     71:   function Transpose ( t : Transfo ) return Transfo;
                     72:
                     73:   -- DESCRIPTION :
                     74:   --   Returns the transposed transformation.
                     75:
                     76:   function Invert ( t : Transfo ) return Transfo;
                     77:
                     78:   -- DESCRIPTION :
                     79:   --   Computes the inverse transformation of t;
                     80:   --   after t1 := Invert(t), t1*t = t*t1 = Id.
                     81:
                     82:   -- REQUIRED : t is an isomorphism.
                     83:
                     84:   function "*" ( t1,t2 : Transfo ) return Transfo;
                     85:
                     86:   -- DESCRIPTION :
                     87:   --   Returns t1 after t2
                     88:
                     89:   procedure Mult1 ( t1 : in out Transfo; t2 : in Transfo );
                     90:
                     91:   -- DESCRIPTION :
                     92:   --   t1 := t1 * t2;  but with an efficient memory management
                     93:
                     94:   procedure Mult2 ( t1 : in Transfo; t2 : in out Transfo );
                     95:
                     96:   -- DESCRIPTION :
                     97:   --   t2 := t1 * t2;  but with an efficient memory management
                     98:
                     99:   function "*"( t : Transfo; v : Vector ) return Vector;  -- return t*v;
                    100:   function "*"( t : Transfo; v : Link_to_Vector ) return Link_to_Vector;
                    101:   procedure Apply ( t : in Transfo; v : in out Vector );  -- v := t*v;
                    102:   procedure Apply ( t : in Transfo; v : in out Link_to_Vector );
                    103:
                    104:   function "*" ( t : Transfo; v : Standard_Complex_Vectors.Vector )
                    105:                return Standard_Complex_Vectors.Vector;
                    106:   procedure Apply ( t : in Transfo;
                    107:                     v : in out Standard_Complex_Vectors.Vector ); -- v := t*v;
                    108:
                    109: -- DESTRUCTOR :
                    110:
                    111:   procedure Clear ( t : in out Transfo );
                    112:
                    113:   -- DESCRIPTION :
                    114:   --   Frees all allocated memory space
                    115:
                    116: private
                    117:
                    118:   type Transfo_tp;
                    119:   type Transfo is access Transfo_tp;
                    120:
                    121: end Transformations;