Return to READ_ME CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Math_Lib / Matrices

Import the second public release of PHCpack.

OKed by Jan Verschelde.

Integer and floating vectors, matrices and linear-system solvers in PHCv2

New in this release is the availability of multi-precision numbers,
implemented with appropriate Ada 95 concepts.
Also QR decomposition and least squares approximation have been added.

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
--------------------------------------------------------------------------------
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)
multprec_natural_vectors           : vectors of multi-precision 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 multi-precision natural numbers
multprec_natural_matrices_io       : generic_matrices_io(multprec natural)
multprec_integer_vectors           : vectors of multi-precision 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 multi-precision integer numbers
multprec_integer_matrices_io       : generic_matrices_io(multprec integer)
multprec_floating_vectors          : vectors of multi-precision 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 multi-precision floating 
multprec_floating_matrices_io      : generic_matrices_io(multprec floating)
multprec_complex_vectors           : vectors of multi-precision 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)
--------------------------------------------------------------------------------
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 multi-precision integers
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_decomposition : QR-decomposition for standard floats
standard_complex_qr_decomposition  : QR-decomposition of standard complex #s
standard_floating_least_squares    : least squares for standard floats
standard_complex_least_squares     : least squares for standard complex #s
--------------------------------------------------------------------------------
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 multi-precision numbers
multprec_random_vecvecs            : vecvecs of random multi-precision numbers
multprec_random_matrices           : matrices of random multi-precision 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_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
--------------------------------------------------------------------------------
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 f77 library.  Adaptions have been made for multi-precision.
The LINPACK f77 library was also the source for QR and least squares.

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.

This library contains 134 files:
  1 READ_ME file
 92 specifications (ads), including 7 generic packages
 41 implementations (adb), including 11 test programs
wc *adb counts 7742 lines of Ada code.