CVS difference for ais/ai-00296.txt

Differences between 1.6 and version 1.7
Log of other versions for file ais/ai-00296.txt

--- ais/ai-00296.txt	2003/07/03 04:37:46	1.6
+++ ais/ai-00296.txt	2003/07/24 22:51:57	1.7
@@ -1,4 +1,4 @@
-!standard G (00)                                        03-05-22  AI95-00296/02
+!standard G (00)                                        03-07-22  AI95-00296/03
 !class amendment 02-06-07
 !status work item 03-01-23
 !status received 02-06-07
@@ -71,8 +71,10 @@
    type Real_Vector is array (Integer range <>) of Real'Base;
    type Real_Matrix is array (Integer range <>, Integer range <>) of Real'Base;
 
-   -- Real_Vector additive operations
+   -- Subprograms for Real_Vector types
 
+   -- Real_Vector arithmetic operations
+
    function "+"   (Right : Real_Vector)       return Real_Vector;
    function "-"   (Right : Real_Vector)       return Real_Vector;
    function "abs" (Right : Real_Vector)       return Real_Vector;
@@ -80,24 +82,22 @@
    function "+"  (Left, Right : Real_Vector) return Real_Vector;
    function "-"  (Left, Right : Real_Vector) return Real_Vector;
 
+   function "*" (Left, Right : Real_Vector) return Real'Base;
+
    -- Real_Vector scaling operations
 
    function "*" (Left : Real'Base;   Right : Real_Vector) return Real_Vector;
    function "*" (Left : Real_Vector; Right : Real'Base)   return Real_Vector;
    function "/" (Left : Real_Vector; Right : Real'Base)   return Real_Vector;
 
-   -- Inner, Outer and Vector products
-
-   function "*" (Left, Right : Real_Vector) return Real'Base;
-   function "*" (Left, Right : Real_Vector) return Real_Matrix;
-   function "*" (Left, Right : Real_Vector) return Real_Vector;
-
    -- Other Real_Vector operations
 
    function Unit_Vector (Index : Integer;
                          Order : Positive;
                          First : Integer := 1) return Real_Vector;
 
+   -- Subprograms for Real_Matrix types
+
    -- Real_Matrix arithmetic operations
 
    function "+"       (Right : Real_Matrix) return Real_Matrix;
@@ -109,6 +109,8 @@
    function "-" (Left, Right : Real_Matrix) return Real_Matrix;
    function "*" (Left, Right : Real_Matrix) return Real_Matrix;
 
+   function "*" (Left, Right : Real_Vector) return Real_Matrix;
+
    function "*" (Left : Real_Vector; Right : Real_Matrix) return Real_Vector;
    function "*" (Left : Real_Matrix; Right : Real_Vector) return Real_Vector;
 
@@ -173,6 +175,12 @@
 The index range of the result is Left'Range. The exception Constraint_Error
 is raised if Left'Length is not equal to Right'Length.
 
+function "*" (Left, Right : Real_Vector) return Real'Base;
+
+This operation returns the inner product of Left and Right. The exception
+Constraint_Error is raised if Left'Length is not equal to Right'Length. This
+operation involves an inner product.
+
 function "*" (Left : Real'Base; Right : Real_Vector) return Real_Vector;
 
 This operation returns the result of multiplying each component of Right by the
@@ -186,28 +194,6 @@
 the type Real to each component of Left and to the scalar Right. The index
 range of the result is Left'Range.
 
-function "*" (Left, Right : Real_Vector) return Real'Base;
-
-This operation returns the inner product of Left and Right. The exception
-Constraint_Error is raised if Left'Length is not equal to Right'Length. This
-operation involves an inner product.
-
-function "*" (Left, Right : Real_Vector) return Real_Matrix;
-
-This operation returns the outer product of a (column) vector Left by a
-(row) vector Right using the appropriate operation "*" of the type Real for
-computing the individual components. The first and second index ranges of the
-matrix result are Left'Range and Right'Range respectively.
-
-function "*" (Left, Right : Real_Vector) return Real_Vector;
-
-This operation returns the vector product of Left and Right. The exception
-Constraint_Error is raised if Left'Length and Right'Length are not equal to 3.
-The index range of the result is Left'Range.
-
-?? I am not sure about vector product. It only exists in three dimensions and
-is really a skew-symmetric tensor.
-
 function Unit_Vector (Index : Integer;
                       Order : Positive;
                       First : Integer := 1) return Real_Vector;
@@ -247,6 +233,13 @@
 Constraint_Error is raised if Left'Length(2) is not equal to Right'Length(1).
 This operation involves inner products.
 
+function "*" (Left, Right : Real_Vector) return Real_Matrix;
+
+This operation returns the outer product of a (column) vector Left by a
+(row) vector Right using the appropriate operation "*" of the type Real for
+computing the individual components. The first and second index ranges of the
+matrix result are Left'Range and Right'Range respectively.
+
 function "*" (Left : Real_Vector; Right : Real_Matrix) return Real_Vector;
 
 This operation provides the standard mathematical operation for multiplication
@@ -304,9 +297,8 @@
 This function returns the determinant of the matrix A. Constraint_Error is
 raised if A'Length(1) is not equal to A'Length(2).
 
-
 function Unit_Matrix (Order            : Positive;
-                          First_1, First_2 : Integer := 1) return Real_Matrix;
+                      First_1, First_2 : Integer := 1) return Real_Matrix;
 
 This function returns a square "unit matrix" with Order**2 components and
 lower bounds of First_1 and First_2 (for the first and second index ranges
@@ -323,10 +315,8 @@
 requirements are those of the corresponding operations of the type Real in
 both the strict mode and the relaxed mode (see G.2).
 
-?? This doesn't really cover vector product but I might delete it anyway.
-
 For operations involving an inner product, no requirements are specified in
-the relaxed mode. In the strict mode the acuracy should be at least that of
+the relaxed mode. In the strict mode the accuracy should be at least that of
 the canonical implementation of multiplication and addition using the
 corresponding operations of type Real'Base and performing the cumulative
 addition using ascending indices. Implementations shall document any
@@ -341,11 +331,11 @@
 Implementation Advice
 
 Implementations should implement the Solve and Inverse functions using
-established techniques such as Gauss-Seidel with Interchanges.
+established techniques such as Gaussian elimination with row interchanges.
 
 It is not the intention that any special provision should be made to
-determine whether a matrix is ill-conditioned or not. The naturally occuring
-division by zero or overflow which will result from executing these
+determine whether a matrix is ill-conditioned or not. The naturally occurring
+overflow (including division by zero) which will result from executing these
 functions with an ill-conditioned matrix and thus raise Constraint_Error is
 sufficient.
 
@@ -371,6 +361,8 @@
    type Complex_Matrix is array (Integer range <>,
                                  Integer range <>) of Complex;
 
+   -- Subprograms for Complex_Vector types
+
    -- Complex_Vector selection, conversion and composition operations
 
    function Re (X : Complex_Vector) return Real_Vector;
@@ -397,7 +389,7 @@
                                 Cycle             : Real'Base)
                                                     return Complex_Vector;
 
-   -- Complex_Vector additive operations
+   -- Complex_Vector arithmetic operations
 
    function "+"       (Right  : Complex_Vector) return Complex_Vector;
    function "-"       (Right  : Complex_Vector) return Complex_Vector;
@@ -406,8 +398,9 @@
    function "+"  (Left, Right : Complex_Vector) return Complex_Vector;
    function "-"  (Left, Right : Complex_Vector) return Complex_Vector;
 
+   function "*" (Left, Right : Complex_Vector) return Complex;
 
-   -- Mixed Real_Vector and Complex_Vector additive operations
+   -- Mixed Real_Vector and Complex_Vector arithmetic operations
 
    function "+" (Left  : Real_Vector;
                  Right : Complex_Vector) return Complex_Vector;
@@ -418,6 +411,9 @@
    function "-" (Left  : Complex_Vector;
                  Right : Real_Vector)    return Complex_Vector;
 
+   function "*" (Left  : Real_Vector;    Right : Complex_Vector) return Complex;
+   function "*" (Left  : Complex_Vector; Right : Real_Vector)    return Complex;
+
    -- Complex_Vector scaling operations
 
    function "*" (Left  : Complex;
@@ -434,30 +430,14 @@
    function "/" (Left  : Complex_Vector;
                  Right : Real'Base)      return Complex_Vector;
 
-   -- Inner, Outer and Vector products
-
-   function "*" (Left, Right : Complex_Vector) return Complex;
-   function "*" (Left  : Real_Vector;    Right : Complex_Vector) return Complex;
-   function "*" (Left  : Complex_Vector; Right : Real_Vector)    return Complex;
-
-   function "*" (Left, Right : Complex_Vector) return Complex_Matrix;
-   function "*" (Left  : Real_Vector;
-                 Right : Complex_Vector) return Complex_Matrix;
-   function "*" (Left  : Complex_Vector;
-                 Right : Real_Vector)    return Complex_Matrix;
-
-   function "*" (Left, Right : Complex_Vector) return Complex_Vector;
-   function "*" (Left  : Real_Vector;
-                 Right : Complex_Vector) return Complex_Vector;
-   function "*" (Left  : Complex_Vector;
-                 Right : Real_Vector)    return Complex_Vector;
-
    -- Other Complex_Vector operations
 
    function Unit_Vector (Index : Integer;
                          Order : Positive;
                          First : Integer := 1) return Complex_Vector;
 
+   -- Subprograms for Complex_Matrix types
+
    -- Complex_Matrix selection, conversion and composition operations
 
    function Re (X : Complex_Matrix) return Real_Matrix;
@@ -496,6 +476,8 @@
    function "-" (Left, Right : Complex_Matrix) return Complex_Matrix;
    function "*" (Left, Right : Complex_Matrix) return Complex_Matrix;
 
+   function "*" (Left, Right : Complex_Vector) return Complex_Matrix;
+
    function "*" (Left  : Complex_Vector;
                  Right : Complex_Matrix) return Complex_Vector;
    function "*" (Left  : Complex_Matrix;
@@ -517,6 +499,11 @@
                  Right : Real_Matrix)    return Complex_Matrix;
 
    function "*" (Left  : Real_Vector;
+                 Right : Complex_Vector) return Complex_Matrix;
+   function "*" (Left  : Complex_Vector;
+                 Right : Real_Vector)    return Complex_Matrix;
+
+   function "*" (Left  : Real_Vector;
                  Right : Complex_Matrix) return Complex_Vector;
    function "*" (Left  : Complex_Vector;
                  Right : Real_Matrix)    return Complex_Vector;
@@ -569,9 +556,6 @@
 defined similarly, with the names Numerics.Short_Complex_Arrays,
 Numerics.Long_Complex_Arrays, etc.
 
-?? I based this text on that in G.1.2(9/1). However this clause (ie G.3.2)
-doesn't seem to use Imaginary but I left it in.
-
 Two types are defined and exported by Ada.Numerics.Generic_Complex_Arrays.
 The composite type Complex_Vector is provided to represent a vector with
 components of type Complex; it is defined as an unconstrained
@@ -605,7 +589,7 @@
 the components of X by the value of the matching component of Re or Im;
 the other (cartesian) component of each of the components is unchanged.
 The exception Constraint_Error is raised if X'Length is not equal to
-Re'Length and if X'Length is not equal to Im'Length.
+Re'Length or Im'Length.
 
 function Compose_From_Cartesian (Re     : Real_Vector) return Complex_Vector;
 function Compose_From_Cartesian (Re, Im : Real_Vector) return Complex_Vector;
@@ -655,6 +639,18 @@
 function "+" (Left, Right : Complex_Vector) return Complex_Vector;
 function "-" (Left, Right : Complex_Vector) return Complex_Vector;
 
+Each operation returns the result of applying the corresponding operation
+in Numerics.Generic_Complex_Types to each component of Left and the
+matching component of Right. The index range of the result is Left'Range.
+The exception Constraint_Error is raised if Left'Length is not equal to
+Right'Length.
+
+function "*" (Left, Right : Complex_Vector) return Complex;
+
+This operation returns the inner product of Left and Right. The exception
+Constraint_Error is raised if Left'Length is not equal to Right'Length.
+This operation involves an inner product.
+
 function "+" (Left  : Real_Vector;
               Right : Complex_Vector) return Complex_Vector;
 function "+" (Left  : Complex_Vector;
@@ -670,6 +666,13 @@
 The exception Constraint_Error is raised if Left'Length is not equal to
 Right'Length.
 
+function "*" (Left : Real_Vector;    Right : Complex_Vector) return Complex;
+function "*" (Left : Complex_Vector; Right : Real_Vector)    return Complex;
+
+Each operation returns the inner product of Left and Right. The exception
+Constraint_Error is raised if Left'Length is not equal to Right'Length.
+These operations involve an inner product.
+
 function "*" (Left : Complex; Right : Complex_Vector) return Complex_Vector;
 
 This operation returns the result of multiplying each component of Right by
@@ -696,36 +699,6 @@
 Numerics.Generic_Complex_Types to each component of the vector Left and the
 real number Right. The index range of the result is Left'Range.
 
-function "*" (Left, Right : Complex_Vector) return Complex;
-function "*" (Left : Real_Vector;    Right : Complex_Vector) return Complex;
-function "*" (Left : Complex_Vector; Right : Real_Vector)    return Complex;
-
-Each operation returns the inner product of Left and Right. The exception
-Constraint_Error is raised if Left'Length is not equal to Right'Length.
-These operations involve an inner product.
-
-function "*" (Left, Right : Complex_Vector) return Complex_Matrix;
-function "*" (Left  : Real_Vector;
-              Right : Complex_Vector) return Complex_Matrix;
-function "*" (Left  : Complex_Vector;
-              Right : Real_Vector)    return Complex_Matrix;
-
-Each operation returns the outer product of a (column) vector Left by a (row)
-vector Right using the appropriate operation "*" in
-Numerics.Generic_Complex_Types for computing the individual components.
-The first and second index ranges of the matrix result are Left'Range and
-Right'Range respectively.
-
-function "*" (Left, Right : Complex_Vector) return Complex_Vector;
-function "*" (Left  : Real_Vector;
-              Right : Complex_Vector) return Complex_Vector;
-function "*" (Left  : Complex_Vector;
-              Right : Real_Vector)    return Complex_Vector;
-
-Each operation returns the vector product of Left and Right. The exception
-Constraint_Error is raised if Left'Length and Right'Length are not equal to 3.
-The index range of the result is Left'Range.
-
 function Unit_Vector (Index : Integer;
                       Order : Positive;
                       First : Integer := 1) return Complex_Vector;
@@ -749,8 +722,7 @@
 components of X by the value of the matching component of Re or Im; the other
 (cartesian) component of each of the components is unchanged. The exception
 Constraint_Error is raised if X'Length(1) is not equal to Re'Length(1) or
-X'Length(2) is not equal to Re'Length(2) and if X'Length(1) is not equal to
-Im'Length(1) or X'Length(2) is not equal to Im'Length(2).
+Im'Length(1) or if X'Length(2) is not equal to Re'Length(2) or Im'Length(2).
 
 function Compose_From_Cartesian (Re     : Real_Matrix) return Complex_Matrix;
 function Compose_From_Cartesian (Re, Im : Real_Matrix) return Complex_Matrix;
@@ -822,6 +794,14 @@
 Constraint_Error is raised if Left'Length(2) is not equal to Right'Length(1).
 This operation involves inner products.
 
+function "*" (Left, Right : Complex_Vector) return Complex_Matrix;
+
+This operation returns the outer product of a (column) vector Left by a (row)
+vector Right using the appropriate operation "*" in
+Numerics.Generic_Complex_Types for computing the individual components.
+The first and second index ranges of the matrix result are Left'Range and
+Right'Range respectively.
+
 function "*" (Left  : Complex_Vector;
               Right : Complex_Matrix) return Complex_Vector;
 
@@ -867,6 +847,17 @@
 These operations involve inner products.
 
 function "*" (Left  : Real_Vector;
+              Right : Complex_Vector) return Complex_Matrix;
+function "*" (Left  : Complex_Vector;
+              Right : Real_Vector)    return Complex_Matrix;
+
+Each operation returns the outer product of a (column) vector Left by a (row)
+vector Right using the appropriate operation "*" in
+Numerics.Generic_Complex_Types for computing the individual components.
+The first and second index ranges of the matrix result are Left'Range and
+Right'Range respectively.
+
+function "*" (Left  : Real_Vector;
               Right : Complex_Matrix) return Complex_Vector;
 function "*" (Left  : Complex_Vector;
               Right : Real_Matrix)    return Complex_Vector;
@@ -963,10 +954,8 @@
 those of the corresponding operations of the type Real'Base and Complex in both
 the strict mode and the relaxed mode (see G.2).
 
-?? This doesn't really cover vector product but I might delete it anyway.
-
 For operations involving an inner product, no requirements are specified in
-the relaxed mode. In the strict mode the acuracy should be at least that of
+the relaxed mode. In the strict mode the accuracy should be at least that of
 the canonical implementation of multiplication and addition using the
 corresponding operations of type Real'Base and Complex and performing the
 cumulative addition using ascending indices. Implementations shall document
@@ -985,17 +974,18 @@
 Implementation Advice
 
 Implementations should implement the Solve and Inverse functions using
-established techniques such as Gauss-Seidel with Interchanges.
+established techniques such as Gaussian elimination with row interchanges.
 
 It is not the intention that any special provision should be made to
-determine whether a matrix is ill-conditioned or not. The naturally occuring
-division by zero or overflow which will result from executing these
+determine whether a matrix is ill-conditioned or not. The naturally occurring
+overflow (including division by zero) which will result from executing these
 functions with an ill-conditioned matrix and thus raise Constraint_Error is
 sufficient.
 
 Implementations should not perform operations on mixed complex and real operands
 by first converting the real operand to complex. See G.1.1(56,57).
 
+
 G.3.3 Eigensystems of Matrices
 
 Eigenvalues and eigenvectors of a real symmetric matrix are computed using
@@ -1043,13 +1033,9 @@
 eigenvalues. The exception Constraint_Error is raised if A'Length(1) is not
 equal to A'Length(2). The index ranges of the parameter Vectors are those of A.
 
-For both subprograms, if the matrix A is not symmetric then Constraint_Error is
+For both subprograms, if the matrix A is not symmetric then Argument_Error is
 raised.
 
-?? Or we could define the matrix just in terms of the upper diagonal or we
-could make it symmetric by taking the arithmetic mean of the matrix and its
-transpose.
-
 Eigenvalues and eigenvectors of a general real or complex matrix are computed
 using subprograms in the child package
 Ada.Numerics.Generic_Complex_Arrays.Eigen whose declaration is:
@@ -1092,9 +1078,6 @@
 are defined similarly, with the names
 Numerics.Short_Complex_Arrays.Eigen, Numerics.Long_Complex_Arrays.Eigen, etc.
 
-?? I didn't mention Real'Base, Complex etc because they are not used in the
-spec.  Should I??
-
 The effect of the subprograms is as described below.
 
 function Values(A : Real_Matrix) return Complex_Vector;
@@ -1118,30 +1101,26 @@
 
 function Values(A : Complex_Matrix) return Real_Vector;
 
-This function returns the eigenvalues of the hermitian matrix A as a vector
+This function returns the eigenvalues of the Hermitian matrix A as a vector
 sorted into order with the largest first. The exception Constraint_Error is
 raised if A'Length(1) is not equal to A'Length(2). The index range of the
-result is A'Range(1). The exception Constraint_Error is raised if the matrix
-is not hermitian.
+result is A'Range(1). The exception Argument_Error is raised if the matrix
+is not Hermitian.
 
 procedure Values_And_Vectors(A       : in  Complex_Matrix;
                              Values  :  out Real_Vector;
                              Vectors :  out Complex_Matrix);
 
-This procedure computes both the eigenvalues and eigenvectors of the hermitian
+This procedure computes both the eigenvalues and eigenvectors of the Hermitian
 matrix A. The out parameter Values is the same as that obtained by calling the
 function Values. The out parameter Vectors is a matrix whose columns are the
 eigenvectors of the matrix A. The order of the columns corresponds to the
 order of the eigenvalues. The eigenvectors are mutually orthonormal,
 including when there are repeated eigenvalues. The exception Constraint_Error
 is raised if A'Length(1) is not equal to A'Length(2). The index ranges of the
-parameter Vectors are those of A. The exception Constraint_Error is raised if
-the matrix is not hermitian.
+parameter Vectors are those of A. The exception Argument_Error is raised if
+the matrix is not Hermitian.
 
-?? Or we could define the matrix just in terms of the upper diagonal or we
-could make it hermitian by taking the arithmetic mean of the matrix and its
-conjugate transpose.
-
 function Values(A : Complex_Matrix) return Complex_Vector;
 
 This function returns the eigenvalues of the matrix A as a vector sorted by
@@ -1171,6 +1150,18 @@
 The nongeneric equivalent packages may, but need not, be actual
 instantiations of the generic package for the appropriate predefined type.
 
+Implementation Advice
+
+The test that a matrix is symmetric may be performed by using the equality
+operator to compare the relevant components. The test that a matrix is
+Hermitian may similarly use the equality operator to compare the real
+components and negation followed by equality to compare the imaginary
+components (see G.2.1).
+
+?? I hope that is good enough. I am not sure whether the RM implies that
+negation is exact. If it doesn't then the paragraph above needs changing or
+G.2.1 needs changing.
+
 
 !example
 
@@ -1189,12 +1180,9 @@
 deleted on the grounds that they are not useful. (They might be useful for
 manipulating arrays in general but we are concerned with arrays used as vectors
 for linear algebra.)
-
-Operations for vector products have been added, However, this might be
-considered curious because they only apply in three-dimensional space.
 
-?? And I put the inner outer and vector products together which might not have
-been a good idea.
+Operations for vector products were considered but not added. This is because,
+as usually defined, they only apply in three-dimensional space.
 
 It is hoped that there is not too much confusion between component when
 applied to the parts of a complex number and component when applied to a part
@@ -1216,7 +1204,7 @@
 
 The names chosen are Solve and Inverse. The former is overloaded, one version
 solves a single set of linear equations; the second solves multiple sets. Note
-that Inverse is not strictly necesssary becuase the effect can be obtained by
+that Inverse is not strictly necessary because the effect can be obtained by
 using Solve and a Unit_Matrix thus
 
 I := Unit_Matrix(A'Length); B := Solve(A, I); -- same as B := Inverse (A);
@@ -1225,13 +1213,14 @@
 deciding whether an array is ill-conditioned and therefore the results of
 inversion might be suspect.
 
-Similar functions have also been added for complex arrays.
+Similar functions have also been added for complex arrays. However, it was not
+deemed necessary to provide for mixed real and complex operands for Solve.
 
 In addition, subprograms have been added for the computation of eigenvalues
 and vectors of real and complex arrays. Because these are somewhat more
 specialized than the elementary operations they have been placed in generic
 child packages such as Numerics.Generic_Real_Arrays.Eigen. The individual
-sunprograms are Values and Values_And_Vectors which means that they can be
+subprograms are Values and Values_And_Vectors which means that they can be
 invoked by statements such as
 
 V := Eigen.Values(A);
@@ -1246,88 +1235,33 @@
 
 A general real matrix can have complex eigenvalues and therefore provision for
 these and complex matrices is in the complex package. Note that the analogue of
-symmetric matrices in the complex domain is hermitian matrices (the transpose
-of a hermitian matrix equals its complex conjugate); these have real
+symmetric matrices in the complex domain is Hermitian matrices (the transpose
+of a Hermitian matrix equals its complex conjugate); these have real
 eigenvalues and distinct provision is made for these. The various overloadings
-are conveniently distinguished by the parameter profiles. (but could not be if
-there were separate fuinctions for the eigenvectors).
+are conveniently distinguished by the parameter profiles (but could not be if
+there were separate functions for the eigenvectors).
 
-?? I am somewhat rusty on eigensystems of non-symmetric matrices. I have said
-nothing about the normalization of the vectors. Note that I put all the eigen
-stuff in 3.3 - that's partly so it can be removed easily!!
-
-The original text of 13813 contains the remark "no complex conjugation is
-performed" in the description of multiplication of complex vectors to produce
-a complex matrix. I removed it because it seemed unhelpful to the user. The
-origin of this according to Donald Sando is that the NUMWG considered including
-various combined operations involving both multiplication and conjugation and
-indeed multiplication and transposition. Multiplication and conjugation are
-natural when dealing with for example Hermitian matrices. however, to provided
-all the appropriate combinations would have greatly increased the size of the
-package so it says in the rationale section F.3 of the 1998 version of 13813.
-
-Terry Froggatt adds further thoughts on this matter (private communication,
-17 July 2001. Thus
-
-2. THOUGHTS ON TRANSPOSITION.
-
-This comment arises from the last paragraph of F.3 of the Rationale in
-Annexe F ....
-
-In the Harrier flight-program we have several spatial co-ordinate systems,
-for example:
-
-Earth Axes: North - East - Up.
-Heading - Cross-heading - Up, (yawed wrt Earth).
-Aircraft Axes (rolled/pitched/yawed wrt Earth).
-HUD Axes (6 degrees down from Aircraft Axes).
-
-Conversion of vectors between pairs of these systems uses matrix
-multiplication one way, and multiplication by the tranpose of the same
-matrix the other way.
-
-Whilst X*CONJUGATE(Y) may be acceptable, since X and Y are the same size,
-the costs for X*TRANSPOSE(Y) are different: Y is generally much bigger than
-X, and it seems rather wasteful (mainly in time) to put the transpose of a
-matrix onto the stack then throw it away.
-
-An alternative is to calculate T := TRANSPOSE(Y) as soon as Y is calculated,
-so that it is available to convert several vectors between a pair of axis
-systems. This is wasteful (mainly in space) because several transposes have
-to be kept around simultaneously.
-
-What we actually use is one routine which implements X*TRANSPOSE(Y) directly:
-it performs the matrix multiplication but traverses Y in transpose-order. This
-takes no more time than the normal multiply, and no space for transposes (just
-code space).
-
-This is exactly what 13813's rationale rejected.
-
-Note that it should be possible to express the Harrier routine, and calls to
-it, quite neatly in Ada. Following the style of "Imaginary", define:
-
-type Transposed_Real_Matrix is private;
-...
-type Transposed_Real_Matrix is new Real_Matrix;
-function Transpose_In_Situ is new Unchecked_Conversion
-(Real_Matrix, Transposed_Real_Matrix);
-
-function "*" (Left: Real_Vector; Right: Transposed_Real_Matrix)
-                                        return (Real_Vector);
-
-This "*" knows it has to traverse Right in transposed order, and can be
-called (using operator notation, and no qualification) by
-
-"Z := X*Transpose_In_Situ(Y);".
-
-END of Remark by Terry Froggatt.
-
-Well now. It seems to me that playing with Hermitian matrices is pretty
-rare and so we can forget about possible combinations of conjugate and
-multiply. However, maybe there is a case for adding some combined
-multiplication and transposition for the real matrices as explained above.
+In the case of eigenvectors of matrices which are neither symmetric nor
+Hermitian no requirement has been placed on the independence or modulus of
+the vectors.
+
+Consideration was given to the inclusion of explicit facilities for LU
+decomposition (as provided for example in the so-called Basic Linear Algebra
+Subprograms (BLAS)). This permits more rapid computation when several
+operations such as solving equations, determinant evaluation and eigensystems
+are to be performed using the same matrix. However, modern hardware is so
+fast that this would only seem to be necessary for very large sets of equations
+which are not the target of these simple facilities. Moroever, adding LU
+decomposition introduces complexity for the user.
+
+Consideration was also given to a fuller implementation of the BLAS. However,
+this seems out of place in a language standard since it would be extremely long
+and specialized. Such a fuller interface to the BLAS could be provided in
+additional child packages. The goal here has been to provide convenient access
+to simple type declarations and the more commonly required operations that are
+not easy for the user to program. These operations can of course be implemented
+as a binding to an implementation of part of the BLAS.
 
-
 !ACATS Test
 
 ACATS test(s) need to be created.
@@ -1661,6 +1595,15 @@
 
 So where do we go from here? It is a slippery slope and I
 fear that I am not an expert.
+
+****************************************************************
+
+From: John Barnes
+Sent: Thursday, July 24, 2003  2:09 AM
+
+Version /03 is as /02 dated 03-05-22 but has vector product removed
+and other minor changes agreed at the ARG meeting in Toulouse. It does not
+include LU decomposition.
 
 ****************************************************************
 

Questions? Ask the ACAA Technical Agent