Vectors, matrices and linear-system solvers in PHCv2.3.22

New in the second release is the availability of multiprecision numbers,
implemented with appropriate Ada 95 concepts.
Also QR decomposition and least squares approximation have been added.
Version 2.1 has an additional package nested vectors to represent
general dimensional matrices of any numbers.
Version 2.2 contains singular value decomposition, which was extended
to multiprecision in version 2.3.

This library is organized in four parts :
1) generic packages: vectors, vectors of vectors, matrices, and _io.
2) instantiations:
      {standard,multprec}_{natural,integer,floating,complex}_
      {vectors,vecvecs,matrices}[_{io}]
3) gcd's and factorizations to solve linear systems
4) random generators and test programs, with prefix ts_*
The organization above is hierarchic.  Other possible views are 
classifications by numeric types (e.g., everything with standard_integer*,
*integer*, etc...) or by data types (e.g., everything with *matrices*,
*vectors*, etc...).

------------------------------------------------------------------------------
file name                          : short description
------------------------------------------------------------------------------
generic_vectors                    : vectors with coefficients in any ring
generic_vectors_io                 : input/output for generic vectors
generic_vecvecs                    : vectors of vectors over any ring
generic_vecvecs_io                 : input/output for vectors of vectors
generic_matrices                   : matrices with coefficients in any ring
generic_matrices_io                : input/output for generic matrices
generic_vecmats                    : vectors of matrices over any ring
generic_vecmats_io                 : input/output for vectors of matrices
generic_nesvecs                    : nested vectors = n-dimensional matrices
generic_nesvecs_io                 : input/output for nested vectors
------------------------------------------------------------------------------
standard_natural_vectors           : vectors of standard natural numbers
standard_natural_vectors_io        : generic_vectors_io(standard natural)
standard_natural_vecvecs           : generic_vecvecs(standard natural)
standard_natural_vecvecs_io        : generic_vecvecs_io(standard natural)
standard_natural_matrices          : matrices of standard natural numbers
standard_natural_matrices_io       : generic_matrices_io(standard natural)
standard_integer_vectors           : vectors of standard integer numbers
standard_integer_vectors_io        : generic_vectors_io(standard integer)
standard_integer_norms             : norms for standard integer vectors
standard_integer_vecvecs           : generic_vecvecs(standard integer)
standard_integer_vecvecs_io        : generic_vecvecs_io(standard integer)
standard_integer_matrices          : matrices of standard integer numbers
standard_integer_matrices_io       : generic_matrices_io(standard integer)
standard_integer_vecmats           : generic_vecmats(standard integer)
standard_integer_vecmats_io        : generic_vecmats_io(standard integer)
standard_floating_vectors          : vectors of standard floating numbers
standard_floating_vectors_io       : generic_vectors_io(standard floating)
standard_floating_vecvecs          : generic_vecvecs(standard floating)
standard_floating_vecvecs_io       : generic_vecvecs_io(standard floating)
standard_floating_matrices         : matrices of standard floating numbers
standard_floating_matrices_io      : generic_matrices_io(standard floating)
standard_floating_vecmats          : generic_vecmats(standard floating)
standard_floating_vecmats_io       : generic_vecmats_io(standard floating)
standard_complex_vectors           : vectors of standard complex numbers
standard_complex_vectors_io        : generic_vectors_io(standard complex)
standard_complex_vecvecs           : generic_vecvecs(standard complex)
standard_complex_vecvecs_io        : generic_vecvecs_io(standard complex)
standard_complex_matrices          : matrices of standard complex numbers
standard_complex_matrices_io       : generic_matrices_io(standard complex)
standard_complex_vecmats           : generic_vecmats(standard complex)
standard_complex_vecmats_io        : generic_vecmats_io(standard complex)
standard_complex_nesvecs           : generic_nesvecs(standard complex)
standard_complex_nesvecs_io        : generic_nesvecs_io(standard complex)
multprec_natural_vectors           : vectors of multiprecision natural numbers
multprec_natural_vectors_io        : generic_vectors_io(multprec natural)
multprec_natural_vecvecs           : generic_vecvecs(multprec natural)
multprec_natural_vecvecs_io        : generic_vecvecs_io(multprec natural)
multprec_natural_matrices          : matrices of multiprecision natural numbers
multprec_natural_matrices_io       : generic_matrices_io(multprec natural)
multprec_integer_vectors           : vectors of multiprecision integer numbers
multprec_integer_vectors_io        : generic_vectors_io(multprec integer)
multprec_integer_vecvecs           : generic_vecvecs(multprec integer)
multprec_integer_vecvecs_io        : generic_vecvecs_io(multprec integer)
multprec_integer_matrices          : matrices of multiprecision integer numbers
multprec_integer_matrices_io       : generic_matrices_io(multprec integer)
multprec_floating_vectors          : vectors of multiprecision floating numbers
multprec_floating_vectors_io       : generic_vectors_io(multprec floating)
multprec_floating_vecvecs          : generic_vecvecs(multprec floating)
multprec_floating_vecvecs_io       : generic_vecvecs_io(multprec floating)
multprec_floating_matrices         : matrices of multiprecision floating 
multprec_floating_matrices_io      : generic_matrices_io(multprec floating)
multprec_complex_vectors           : vectors of multiprecision complex numbers
multprec_complex_vectors_io        : generic_vectors_io(multprec complex)
multprec_complex_vecvecs           : generic_vecvecs(multprec complex)
multprec_complex_vecvecs_io        : generic_vecvecs_io(multprec complex)
multprec_complex_nesvecs           : generic_nesvecs(multprec complex)
multprec_complex_nesvecs_io        : generic_nesvecs_io(multprec complex)
multprec_complex_vecmats           : generic_vecmats(multprec complex)
multprec_complex_vecmats_io        : generic_vecmats_io(multprec complex)
------------------------------------------------------------------------------
greatest_common_divisors           : greatest common divisors over any domain
standard_common_divisors           : gcd/lcm for the standard integer numbers
multprec_common_divisors           : gcd/lcm for the multiprecision integers
smith_normal_form                  : Smith Normal Form of integer matrix
generic_integer_linear_solvers     : solvers of linear systems over any domain
standard_integer_linear_solvers    : linear-system solvers for standard integers
standard_integer_linear_equalities : manipulation of linear equalities
multprec_integer_linear_solvers    : linear-system solvers for multprec integers
generic_floating_linear_solvers    : solvers of linear systems of floats
standard_floating_linear_solvers   : linear-system solvers for standard floats
multprec_floating_linear_solvers   : linear-system solvers for multprec floats
standard_complex_linear_solvers    : linear-system solvers for standard complex
multprec_complex_linear_solvers    : linear-system solvers for multprec complex
generic_norms_equals               : norms and equality routines
standard_floating_norms_equals     : norms/equals for standard floating numbers
standard_floating_two_norms        : Euclidean norms for standard floating vecs
multprec_floating_norms_equals     : norms/equals for multprec floating numbers
standard_complex_norms_equals      : norms/equals for standard complex numbers
multprec_complex_norms_equals      : norms/equals for multprec complex numbers
standard_floating_qr_least_squares : QR + least squares for standard floats
standard_complex_qr_least_squares  : QR + least squares for standard complex #s
multprec_complex_qr_least_squares  : QR + least squares for multprec complex #s
standard_complex_singular_values   : SVD in standard arithmetic
multprec_complex_singular_values   : SVD in multiprecision arithmetic
standard_complex_row_reduction     : tools for incremental row reduction
------------------------------------------------------------------------------
standard_random_vectors            : vectors of random standard numbers
standard_random_vecvecs            : vecvecs of random standard numbers
standard_random_matrices           : matrices of random standard numbers
multprec_random_vectors            : vectors of random multiprecision numbers
multprec_random_vecvecs            : vecvecs of random multiprecision numbers
multprec_random_matrices           : matrices of random multiprecision numbers
------------------------------------------------------------------------------
ts_natvec                          : test vectors/vecvecs of natural numbers
ts_natmat                          : test matrices of natural numbers
ts_intvec                          : test vectors/vecvecs of integer numbers
ts_intmat                          : test solvers of integer numbers
ts_gcd                             : test greatest common divisors
ts_smith                           : test on Smith normal form
ts_fltvec                          : test vectors/vecvecs of floating numbers
ts_fltmat                          : test solvers of floating linear systems
ts_fltdls                          : test dynamic matrix triangulators
ts_cmpvec                          : test vectors/vecvecs of complex numbers
ts_cmpmat                          : test solvers of complex linear systems
ts_qrd                             : test QR-decomposition and least squares
ts_svd                             : test singular value decomposition
ts_nesvec                          : test on nested vectors
ts_rowred                          : test incremental row reduction
------------------------------------------------------------------------------
The generic_* packages are different from the abstract_* packages in the
sense that they export types and operations, i.e.: they have a body.

The LU-factorizations for real and complex numbers have been translated from
the LINPACK f66 library.  Adaptions have been made for multiprecision.
The LINPACK f66 library was also the source for QR and least squares,
and the singular values decomposition.

There are three types of linear systems: over integer, floating-point reals
and complex numbers.  For each numeric type, there is only one generic
implementation, except for the complex numbers, where it became too complex
to elaborate the mixed floating-complex arithmetic with generics.
Also with norms and equalities, no generics are used for complex numbers.
