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.