# CVS difference for ais/ai-00296.txt

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

```--- ais/ai-00296.txt	2005/04/13 05:37:08	1.20
+++ ais/ai-00296.txt	2005/10/31 05:18:25	1.21
@@ -1,6 +1,8 @@
-!standard G.3 (01)                                     05-03-10  AI95-00296/10
+!standard G.3 (01)                                     05-10-06  AI95-00296/11
!standard G.3.1 (01)
!standard G.3.2 (01)
+!standard G   (05)
+!standard G   (06)
!class amendment 02-06-07
!status Amendment 200Y 04-01-13
!status WG9 Approved 04-06-18
@@ -48,6 +50,10 @@

!wording

+
+* features for the manipulation of real and complex vectors and matrices.
+
Add a new clause G.3 as follows

G.3 Vector and Matrix Manipulation
@@ -127,7 +133,7 @@

-- Real_Matrix inversion and related operations

-   function Solve (A : Real_Matrix; X: Real_Vector) return Real_Vector;
+   function Solve (A : Real_Matrix; X : Real_Vector) return Real_Vector;
function Solve (A, X : Real_Matrix) return Real_Matrix;
function Inverse (A : Real_Matrix) return Real_Matrix;
function Determinant (A : Real_Matrix) return Real'Base;
@@ -162,8 +168,8 @@
a matrix with components of type Real; it is defined as an unconstrained,
two-dimensional array with indices of type Integer.

-The effect of the various functions is as described below. In most cases the
-functions are described in terms of corresponding scalar operations of the type
+The effect of the various subprograms is as described below. In most cases the
+subprograms are described in terms of corresponding scalar operations of the type
Real; any exception raised by those operations is propagated by the array
operation. Moreover, the accuracy of the result for each individual component is
as defined for the scalar operation unless stated otherwise.
@@ -251,7 +257,7 @@
This operation returns the outer product of a (column) vector Left by a
(row) vector Right using the 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.
+result are Left'Range and Right'Range respectively.

function "*" (Left : Real_Vector; Right : Real_Matrix) return Real_Vector;

@@ -273,21 +279,21 @@

This operation returns the result of multiplying each component of Right by the
scalar Left using the "*" operation of the type Real. The index ranges of the
-matrix result are those of Right.
+result are those of Right.

function "*" (Left : Real_Matrix; Right : Real'Base) return Real_Matrix;
function "/" (Left : Real_Matrix; Right : Real'Base) return Real_Matrix;

Each operation returns the result of applying the corresponding operation of
the type Real to each component of Left and to the scalar Right. The index
-ranges of the matrix result are those of Left.
+ranges of the result are those of Left.

-function Solve (A : Real_Matrix; X: Real_Vector) return Real_Vector;
+function Solve (A : Real_Matrix; X : Real_Vector) return Real_Vector;

This function returns a vector Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving a single set of linear
-equations. The index range of the result is X'Range. Constraint_Error is
-raised if A'Length(1), A'Length(2) and X'Length are not equal.
+equations. The index range of the result is A'Range(2). Constraint_Error is
+raised if A'Length(1), A'Length(2), and X'Length are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.

function Solve (A, X : Real_Matrix) return Real_Matrix;
@@ -295,13 +301,13 @@
This function returns a matrix Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving several sets of linear
equations. The index ranges of the result are those of X. Constraint_Error
-is raised if A'Length(1), A'Length(2) and X'Length(1) are not equal.
+is raised if A'Length(1), A'Length(2), and X'Length(1) are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.

function Inverse (A : Real_Matrix) return Real_Matrix;

This function returns a matrix B such that A * B is (nearly) equal to the unit
-matrix. The index ranges of the result are those of A. Constraint_Error is
+matrix. The index ranges of the result are A'Ramge(2) and A'Range(1). Constraint_Error is
raised if A'Length(1) is not equal to A'Length(2). Constraint_Error is raised
if the matrix A is ill-conditioned.

@@ -391,7 +397,7 @@
functions with an ill-conditioned matrix and thus raise Constraint_Error is
sufficient.

-The test that a matrix is symmetric may be performed by using the equality
+The test that a matrix is symmetric should be performed by using the equality
operator to compare the relevant components.

G.3.2 Complex Vectors and Matrices
@@ -584,7 +590,7 @@

-- Complex_Matrix inversion and related operations

-   function Solve (A : Complex_Matrix; X: Complex_Vector) return Complex_Vector;
+   function Solve (A : Complex_Matrix; X : Complex_Vector) return Complex_Vector;
function Solve (A, X : Complex_Matrix) return Complex_Matrix;
function Inverse (A : Complex_Matrix) return Complex_Matrix;
function Determinant (A : Complex_Matrix) return Complex;
@@ -638,23 +644,23 @@
function Re (X : Complex_Vector) return Real_Vector;
function Im (X : Complex_Vector) return Real_Vector;

-Each function returns a vector of the specified cartesian components of X.
+Each function returns a vector of the specified Cartesian components of X.
The index range of the result is X'Range.

procedure Set_Re (X  : in out Complex_Vector; Re : in Real_Vector);
procedure Set_Im (X  : in out Complex_Vector; Im : in Real_Vector);

-Each procedure replaces the specified (cartesian) component of each of
+Each procedure replaces the specified (Cartesian) component of each of
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 other (Cartesian) component of each of the components is unchanged.
Constraint_Error is raised if X'Length is not equal to
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;

-Each function constructs a vector of Complex results (in cartesian
-representation) formed from given vectors of cartesian components; when
+Each function constructs a vector of Complex results (in Cartesian
+representation) formed from given vectors of Cartesian components; when
only the real components are given, imaginary components of zero are assumed.
The index range of the result is Re'Range. Constraint_Error is
raised if Re'Length is not equal to Im'Length.
@@ -675,7 +681,7 @@
function Compose_From_Polar (Modulus, Argument : Real_Vector; Cycle : Real'Base)
return Complex_Vector;

-Each function constructs a vector of Complex results (in cartesian
+Each function constructs a vector of Complex results (in Cartesian
representation) formed from given vectors of polar components using the
corresponding function in Numerics.Generic_Complex_Types on matching
components of Modulus and Argument. The index range of the result is
@@ -763,31 +769,31 @@
First : Integer := 1) return Complex_Vector;

This function returns a "unit vector" with Order components and a lower
-bound of First. All components are set to (0.0,0.0) except for the Index
-component which is set to (1.0,0.0). Constraint_Error is
+bound of First. All components are set to (0.0, 0.0) except for the Index
+component which is set to (1.0, 0.0). Constraint_Error is
raised if Index < First, Index > First + Order - 1, or
if First + Order - 1 > Integer'Last.

function Re (X : Complex_Matrix) return Real_Matrix;
function Im (X : Complex_Matrix) return Real_Matrix;

-Each function returns a matrix of the specified cartesian components of X.
+Each function returns a matrix of the specified Cartesian components of X.
The index ranges of the result are those of X.

procedure Set_Re (X : in out Complex_Matrix; Re : in Real_Matrix);
procedure Set_Im (X : in out Complex_Matrix; Im : in Real_Matrix);

-Each procedure replaces the specified (cartesian) component of each of the
+Each procedure replaces the specified (Cartesian) component of each of 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.
+(Cartesian) component of each of the components is unchanged.
Constraint_Error is raised if X'Length(1) is not equal to Re'Length(1) or
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;

-Each function constructs a matrix of Complex results (in cartesian
-representation) formed from given matrices of cartesian components; when
+Each function constructs a matrix of Complex results (in Cartesian
+representation) formed from given matrices of Cartesian components; when
only the real components are given, imaginary components of zero are
assumed. The index ranges of the result are those of Re.
Constraint_Error is raised if Re'Length(1) is not equal to Im'Length(1) or
@@ -810,7 +816,7 @@
Cycle             : Real'Base)
return Complex_Matrix;

-Each function constructs a matrix of Complex results (in cartesian
+Each function constructs a matrix of Complex results (in Cartesian
representation) formed from given matrices of polar components using
the corresponding function in Numerics.Generic_Complex_Types on matching
components of Modulus and Argument. The index ranges of the result are those
@@ -858,7 +864,7 @@
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
+The first and second index ranges of the result are Left'Range and
Right'Range respectively.

function "*" (Left  : Complex_Vector;
@@ -913,7 +919,7 @@
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
+The first and second index ranges of the result are Left'Range and
Right'Range respectively.

function "*" (Left  : Real_Vector;
@@ -966,26 +972,28 @@
Numerics.Generic_Complex_Types to each component of the matrix Left and the
real number Right. The index ranges of the result are those of Left.

-function Solve (A : Complex_Matrix; X: Complex_Vector) return Complex_Vector;
+function Solve (A : Complex_Matrix; X : Complex_Vector) return Complex_Vector;

This function returns a vector Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving a single set of linear
-equations. The index range of the result is X'Range. Constraint_Error is
-raised if A'Length(1), A'Length(2) and X'Length are not equal.
+equations. The index range of the result is A'Range(2). Constraint_Error is
+raised if A'Length(1), A'Length(2), and X'Length are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.

function Solve (A, X : Complex_Matrix) return Complex_Matrix;

This function returns a matrix Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving several sets of linear
-equations. The index ranges of the result are those of X. Constraint_Error
-is raised if A'Length(1), A'Length(2) and X'Length(1) are not equal.
+equations. The index ranges of the result are A'Range(2) and X'Range(2).
+Constraint_Error
+is raised if A'Length(1), A'Length(2), and X'Length(1) are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.

function Inverse (A : Complex_Matrix) return Complex_Matrix;

This function returns a matrix B such that A * B is (nearly) equal to the unit
-matrix. The index ranges of the result are those of A. Constraint_Error is
+matrix. The index ranges of the result are A'Range(2) and A'Ramge(1).
+Constraint_Error is
raised if A'Length(1) is not equal to A'Length(2). Constraint_Error is raised
if the matrix A is ill-conditioned.

@@ -1022,8 +1030,8 @@

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
-respectively). All components are set to (0.0,0.0) except for the main diagonal,
-whose components are set to (1.0,0.0). Constraint_Error is raised
+respectively). All components are set to (0.0, 0.0) except for the main diagonal,
+whose components are set to (1.0, 0.0). Constraint_Error is raised
if First_1 + Order - 1 > Integer'Last or First_2 + Order - 1 > Integer'Last.

Implementation Requirements
@@ -1299,6 +1307,27 @@
not trivial for the user to program. These operations can of course be
implemented as a binding to an implementation of part of the BLAS.

+!corrigendum G(5)
+
+@drepl
+@xbullet<models of floating point and fixed point arithmetic on which the
+accuracy requirements of strict mode are based; and>
+@dby
+@xbullet<models of floating point and fixed point arithmetic on which the
+accuracy requirements of strict mode are based;>
+
+!corrigendum G(6)
+
+@drepl
+@xbullet<the definitions of the model-oriented attributes of floating point
+types that apply in the strict mode.>
+@dby
+@xbullet<the definitions of the model-oriented attributes of floating point
+types that apply in the strict mode; and>
+
+@xbullet<features for the manipulation of real and complex vectors and
+matrices.>
+
!corrigendum G.3(01)

@dinsc
@@ -1381,7 +1410,7 @@

-- @ft<@i<Real_Matrix inversion and related operations>>

-   @b<function> Solve (A : Real_Matrix; X: Real_Vector) @b<return> Real_Vector;
+   @b<function> Solve (A : Real_Matrix; X : Real_Vector) @b<return> Real_Vector;
@b<function> Solve (A, X : Real_Matrix) @b<return> Real_Matrix;
@b<function> Inverse (A : Real_Matrix) @b<return> Real_Matrix;
@b<function> Determinant (A : Real_Matrix) @b<return> Real'Base;
@@ -1416,13 +1445,13 @@
a matrix with components of type Real; it is defined as an unconstrained,
two-dimensional array with indices of type Integer.

-The effect of the various functions is as described below. In most cases the
-functions are described in terms of corresponding scalar operations of the type
+The effect of the various subprograms is as described below. In most cases the
+subprograms are described in terms of corresponding scalar operations of the type
Real; any exception raised by those operations is propagated by the array
operation. Moreover, the accuracy of the result for each individual component is
as defined for the scalar operation unless stated otherwise.

-In the case of those operations which are defined to involve an inner product,
+In the case of those operations which are defined to @i<involve an inner product>,
Constraint_Error may be raised if an intermediate result is outside the range
of Real'Base even though the mathematical final result would not be.

@@ -1505,7 +1534,7 @@
@xindent<This operation returns the outer product of a (column) vector Left by a
(row) vector Right using the 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.>
+result are Left'Range and Right'Range respectively.>

@xcode<@b<function> "*" (Left : Real_Vector; Right : Real_Matrix) @b<return> Real_Vector;>

@@ -1527,20 +1556,20 @@

@xindent<This operation returns the result of multiplying each component of Right by the
scalar Left using the "*" operation of the type Real. The index ranges of the
-matrix result are those of Right.>
+result are those of Right.>

@xcode<@b<function> "*" (Left : Real_Matrix; Right : Real'Base) @b<return> Real_Matrix;
@b<function> "/" (Left : Real_Matrix; Right : Real'Base) @b<return> Real_Matrix;>

@xindent<Each operation returns the result of applying the corresponding operation of
the type Real to each component of Left and to the scalar Right. The index
-ranges of the matrix result are those of Left.>
+ranges of the result are those of Left.>

-@xcode<@b<function> Solve (A : Real_Matrix; X: Real_Vector) @b<return> Real_Vector;>
+@xcode<@b<function> Solve (A : Real_Matrix; X : Real_Vector) @b<return> Real_Vector;>

@xindent<This function returns a vector Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving a single set of linear
-equations. The index range of the result is X'Range. Constraint_Error is
+equations. The index range of the result is A'Range(2). Constraint_Error is
raised if A'Length(1), A'Length(2) and X'Length are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.>

@@ -1548,14 +1577,14 @@

@xindent<This function returns a matrix Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving several sets of linear
-equations. The index ranges of the result are those of X. Constraint_Error
-is raised if A'Length(1), A'Length(2) and X'Length(1) are not equal.
-Constraint_Error is raised if the matrix A is ill-conditioned.>
+equations. The index ranges of the result are A'Ramge(2) and X'Range(2).
+Constraint_Error is raised if A'Length(1), A'Length(2) and X'Length(1)
+are not equal. Constraint_Error is raised if the matrix A is ill-conditioned.>

@xcode<@b<function> Inverse (A : Real_Matrix) @b<return> Real_Matrix;>

@xindent<This function returns a matrix B such that A * B is (nearly) equal to
-the unit matrix. The index ranges of the result are those of A.
+the unit matrix. The index ranges of the result are A'Range(2) and A'Range(1).
Constraint_Error is raised if A'Length(1) is not equal to A'Length(2).
Constraint_Error is raised if the matrix A is ill-conditioned.>

@@ -1606,7 +1635,7 @@

For operations involving an inner product, no requirements are specified in
the relaxed mode. In the strict mode the modulus of the absolute error of
-the inner product @i<X>*@i<Y> shall not exceed @i<g>*@b<abs>(@i<X>)*abs(@i<Y>)
+the inner product @i<X>*@i<Y> shall not exceed @i<g>*@b<abs>(@i<X>)*@b<abs>(@i<Y>)
where @i<g> is defined as

@@ -1634,7 +1663,7 @@
functions with an ill-conditioned matrix and thus raise Constraint_Error is
sufficient.

-The test that a matrix is symmetric may be performed by using the equality
+The test that a matrix is symmetric should be performed by using the equality
operator to compare the relevant components.

!corrigendum G.3.2(01)
@@ -1836,7 +1865,7 @@

-- @ft<@i<Complex_Matrix inversion and related operations>>

-   @b<function> Solve (A : Complex_Matrix; X: Complex_Vector)
+   @b<function> Solve (A : Complex_Matrix; X : Complex_Vector)
@b<return> Complex_Vector;
@b<function> Solve (A, X : Complex_Matrix) @b<return> Complex_Matrix;
@b<function> Inverse (A : Complex_Matrix) @b<return> Complex_Matrix;
@@ -1883,7 +1912,7 @@
and the accuracy of the result for each individual component are as defined for
the scalar operation.

-In the case of those operations which are defined to involve an inner product,
+In the case of those operations which are defined to @i<involve an inner product>,
Constraint_Error may be raised if an intermediate result has a component
outside the range of Real'Base even though the final mathematical result
would not.
@@ -1891,23 +1920,23 @@
@xcode<@b<function> Re (X : Complex_Vector) @b<return> Real_Vector;
@b<function> Im (X : Complex_Vector) @b<return> Real_Vector;>

-@xindent<Each function returns a vector of the specified cartesian components of X.
+@xindent<Each function returns a vector of the specified Cartesian components of X.
The index range of the result is X'Range.>

@xcode<@b<procedure> Set_Re (X  : @b<in out> Complex_Vector; Re : @b<in> Real_Vector);
@b<procedure> Set_Im (X  : @b<in out> Complex_Vector; Im : @b<in> Real_Vector);>

-@xindent<Each procedure replaces the specified (cartesian) component of each of
+@xindent<Each procedure replaces the specified (Cartesian) component of each of
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 other (Cartesian) component of each of the components is unchanged.
Constraint_Error is raised if X'Length is not equal to
Re'Length or Im'Length.>

@xcode<@b<function> Compose_From_Cartesian (Re     : Real_Vector) @b<return> Complex_Vector;
@b<function> Compose_From_Cartesian (Re, Im : Real_Vector) @b<return> Complex_Vector;>

-@xindent<Each function constructs a vector of Complex results (in cartesian
-representation) formed from given vectors of cartesian components; when
+@xindent<Each function constructs a vector of Complex results (in Cartesian
+representation) formed from given vectors of Cartesian components; when
only the real components are given, imaginary components of zero are assumed.
The index range of the result is Re'Range. Constraint_Error is
raised if Re'Length is not equal to Im'Length.>
@@ -1929,7 +1958,7 @@
Cycle             : Real'Base)
@b<return> Complex_Vector;>

-@xindent<Each function constructs a vector of Complex results (in cartesian
+@xindent<Each function constructs a vector of Complex results (in Cartesian
representation) formed from given vectors of polar components using the
corresponding function in Numerics.Generic_Complex_Types on matching
components of Modulus and Argument. The index range of the result is
@@ -2017,31 +2046,31 @@
First : Integer := 1) @b<return> Complex_Vector;>

@xindent<This function returns a @i<unit vector> with Order components and a lower
-bound of First. All components are set to (0.0,0.0) except for the Index
-component which is set to (1.0,0.0). Constraint_Error is
+bound of First. All components are set to (0.0, 0.0) except for the Index
+component which is set to (1.0, 0.0). Constraint_Error is
raised if Index < First, Index @> First + Order - 1, or
if First + Order - 1 @> Integer'Last.>

@xcode<@b<function> Re (X : Complex_Matrix) @b<return> Real_Matrix;
@b<function> Im (X : Complex_Matrix) @b<return> Real_Matrix;>

-@xindent<Each function returns a matrix of the specified cartesian components of X.
+@xindent<Each function returns a matrix of the specified Cartesian components of X.
The index ranges of the result are those of X.>

@xcode<@b<procedure> Set_Re (X : @b<in out> Complex_Matrix; Re : @b<in> Real_Matrix);
@b<procedure> Set_Im (X : @b<in out> Complex_Matrix; Im : @b<in> Real_Matrix);>

-@xindent<Each procedure replaces the specified (cartesian) component of each of the
+@xindent<Each procedure replaces the specified (Cartesian) component of each of 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.
+(Cartesian) component of each of the components is unchanged.
Constraint_Error is raised if X'Length(1) is not equal to Re'Length(1) or
Im'Length(1) or if X'Length(2) is not equal to Re'Length(2) or Im'Length(2).>

@xcode<@b<function> Compose_From_Cartesian (Re     : Real_Matrix) @b<return> Complex_Matrix;
@b<function> Compose_From_Cartesian (Re, Im : Real_Matrix) @b<return> Complex_Matrix;>

-@xindent<Each function constructs a matrix of Complex results (in cartesian
-representation) formed from given matrices of cartesian components; when
+@xindent<Each function constructs a matrix of Complex results (in Cartesian
+representation) formed from given matrices of Cartesian components; when
only the real components are given, imaginary components of zero are
assumed. The index ranges of the result are those of Re.
Constraint_Error is raised if Re'Length(1) is not equal to Im'Length(1) or
@@ -2064,7 +2093,7 @@
Cycle             : Real'Base)
@b<return> Complex_Matrix;>

-@xindent<Each function constructs a matrix of Complex results (in cartesian
+@xindent<Each function constructs a matrix of Complex results (in Cartesian
representation) formed from given matrices of polar components using
the corresponding function in Numerics.Generic_Complex_Types on matching
components of Modulus and Argument. The index ranges of the result are those
@@ -2112,7 +2141,7 @@
@xindent<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
+The first and second index ranges of the result are Left'Range and
Right'Range respectively.>

@xcode<@b<function> "*" (Left  : Complex_Vector;
@@ -2167,7 +2196,7 @@
@xindent<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
+The first and second index ranges of the result are Left'Range and
Right'Range respectively.>

@xcode<@b<function> "*" (Left  : Real_Vector;
@@ -2220,11 +2249,11 @@
Numerics.Generic_Complex_Types to each component of the matrix Left and the
real number Right. The index ranges of the result are those of Left.>

-@xcode<@b<function> Solve (A : Complex_Matrix; X: Complex_Vector) @b<return> Complex_Vector;>
+@xcode<@b<function> Solve (A : Complex_Matrix; X : Complex_Vector) @b<return> Complex_Vector;>

@xindent<This function returns a vector Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving a single set of linear
-equations. The index range of the result is X'Range. Constraint_Error is
+equations. The index range of the result is A'Range(2). Constraint_Error is
raised if A'Length(1), A'Length(2) and X'Length are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.>

@@ -2232,14 +2261,14 @@

@xindent<This function returns a matrix Y such that X is (nearly) equal to A * Y. This
is the standard mathematical operation for solving several sets of linear
-equations. The index ranges of the result are those of X. Constraint_Error
+equations. The index ranges of the result are A'Ramge(2) and X'Ramge(2). Constraint_Error
is raised if A'Length(1), A'Length(2) and X'Length(1) are not equal.
Constraint_Error is raised if the matrix A is ill-conditioned.>

@xcode<@b<function> Inverse (A : Complex_Matrix) @b<return> Complex_Matrix;>

@xindent<This function returns a matrix B such that A * B is (nearly) equal to
-the unit matrix. The index ranges of the result are those of A.
+the unit matrix. The index ranges of the result are A'Ramge(2) and A'Ramge(1).
Constraint_Error is raised if A'Length(1) is not equal to A'Length(2).
Constraint_Error is raised if the matrix A is ill-conditioned.>

@@ -2276,8 +2305,8 @@

@xindent<This function returns a square @i<unit matrix> with Order**2 components and
lower bounds of First_1 and First_2 (for the first and second index ranges
-respectively). All components are set to (0.0,0.0) except for the main diagonal,
-whose components are set to (1.0,0.0). Constraint_Error is raised
+respectively). All components are set to (0.0, 0.0) except for the main diagonal,
+whose components are set to (1.0, 0.0). Constraint_Error is raised
if First_1 + Order - 1 @> Integer'Last or First_2 + Order - 1 @> Integer'Last.>

@i<@s8<Implementation Requirements>>
```

Questions? Ask the ACAA Technical Agent