gh-37663: sage/rings/{complex,real}*: Untitlecase titles, add refs to libraries
    
<!-- ^ Please provide a concise and informative title. -->
<!-- ^ Don't put issue numbers in the title, do this in the PR
description below. -->
<!-- ^ For example, instead of "Fixes #12345" use "Introduce new method
to calculate 1 + 2". -->
<!-- v Describe your changes below in detail. -->
<!-- v Why is this change required? What problem does it solve? -->
<!-- v If this PR resolves an open issue, please link to it here. For
example, "Fixes #12345". -->

This cleans up the table of contents
https://deploy-preview-37663--
sagemath.netlify.app/html/en/reference/rings_numerical/


### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [ ] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - #12345: short description why this is a dependency -->
<!-- - #34567: ... -->

- Depends on #37406 (merged here to resolve merge conflict)
    
URL: #37663
Reported by: Matthias Köppe
Reviewer(s): Marc Mezzarobba

Author: Release Manager

src/doc/en/reference/rings_numerical/index.rst

@@ -4,15 +4,16 @@ Fixed and Arbitrary Precision Numerical Fields
 Floating-Point Arithmetic
 -------------------------
 
-Sage supports arbitrary precision real (RealField) and complex fields
-(ComplexField). Sage also provides two optimized fixed precision fields for
-numerical computation, the real double (RealDoubleField) and complex double
-fields (ComplexDoubleField).
+Sage supports arbitrary precision real (:class:`RealField`) and complex fields
+(:class:`ComplexField`). Sage also provides two optimized fixed precision fields for
+numerical computation, the real double (:class:`RealDoubleField`) and complex double
+fields (:class:`ComplexDoubleField`).
 
 Real and complex double elements are optimized implementations that use the
-GNU Scientific Library for arithmetic and some special functions.  Arbitrary
-precision real and complex numbers are implemented using the MPFR library,
-which builds on GMP. In many cases the PARI C-library is used to compute
+:ref:`GNU Scientific Library <spkg_gsl>` for arithmetic and some special functions.
+Arbitrary precision real and complex numbers are implemented using the
+:ref:`MPFR <spkg_mpfr>` library, which builds on :ref:`GMP <spkg_gmp>`.
+In many cases, the :ref:`PARI <spkg_pari>` C-library is used to compute
 special functions when implementations aren't otherwise available.
 
 .. toctree::
@@ -27,9 +28,9 @@ special functions when implementations aren't otherwise available.
 Interval Arithmetic
 -------------------
 
-Sage implements real and complex interval arithmetic using MPFI
-(RealIntervalField, ComplexIntervalField) and FLINT (RealBallField,
-ComplexBallField).
+Sage implements real and complex interval arithmetic using
+:ref:`MPFI <spkg_mpfi>` (:class:`RealIntervalField`, :class:`ComplexIntervalField`)
+and :ref:`FLINT <spkg_flint>` (:class:`RealBallField`, :class:`ComplexBallField`).
 
 .. toctree::
    :maxdepth: 1

src/sage/rings/complex_double.pyx

@@ -1,15 +1,15 @@
 # distutils: extra_compile_args = -D_XPG6
 # distutils: libraries = m
 r"""
-Double Precision Complex Numbers
+Double precision floating point complex numbers
 
 Sage supports arithmetic using double-precision complex numbers. A
 double-precision complex number is a complex number ``x + I*y`` with
 `x`, `y` 64-bit (8 byte) floating point numbers (double precision).
 
 The field :class:`ComplexDoubleField` implements the field
 of all double-precision complex numbers. You can refer to this
-field by the shorthand CDF. Elements of this field are of type
+field by the shorthand ``CDF``. Elements of this field are of type
 :class:`ComplexDoubleElement`. If `x` and `y` are coercible to
 doubles, you can create a complex double element using
 ``ComplexDoubleElement(x,y)``. You can coerce more
@@ -39,11 +39,12 @@ EXAMPLES::
     True
 
 The underlying arithmetic of complex numbers is implemented using
-functions and macros in GSL (the GNU Scientific Library), and
+functions and macros in :ref:`GSL <spkg_gsl>` (the GNU Scientific Library), and
 should be very fast. Also, all standard complex trig functions,
 log, exponents, etc., are implemented using GSL, and are also
 robust and fast. Several other special functions, e.g. eta, gamma,
-incomplete gamma, etc., are implemented using the PARI C library.
+incomplete gamma, etc., are implemented using the :ref:`PARI <spkg_pari>`
+C library.
 
 AUTHORS:
 

src/sage/rings/complex_interval.pyx

@@ -1,5 +1,5 @@
 """
-Arbitrary Precision Complex Intervals
+Arbitrary precision complex intervals
 
 This is a simple complex interval package, using intervals which are
 axis-aligned rectangles in the complex plane.  It has very few special

src/sage/rings/complex_interval_field.py

@@ -1,5 +1,5 @@
 r"""
-Field of Arbitrary Precision Complex Intervals
+Arbitrary precision complex intervals (parent class)
 
 AUTHORS:
 

src/sage/rings/complex_mpc.pyx

@@ -1,11 +1,11 @@
 """
-Arbitrary Precision Complex Numbers using GNU MPC
+Arbitrary precision floating point complex numbers using GNU MPC
 
-This is a binding for the MPC arbitrary-precision floating point library.
-It is adaptated from ``real_mpfr.pyx`` and ``complex_mpfr.pyx``.
+This is a binding for the arbitrary-precision floating point library
+:ref:`GNU MPC <spkg_mpc>`.
 
-We define a class :class:`MPComplexField`, where each instance of
-``MPComplexField`` specifies a field of floating-point complex numbers with
+We define a class :class:`MPComplexField`, each instance of which
+specifies a field of floating-point complex numbers with
 a specified precision shared by the real and imaginary part and a rounding
 mode stating the rounding mode directions specific to real and imaginary
 parts.
@@ -17,7 +17,8 @@ documentation for the :mod:`sage.rings.real_mpfr`.
 
 AUTHORS:
 
-- Philippe Theveny (2008-10-13): initial version.
+- Philippe Theveny (2008-10-13): initial version, adapted from
+  :mod:`sage.rings.real_mpfr` and :mod:`sage.rings.complex_mpfr`.
 
 - Alex Ghitza (2008-11): cache, generators, random element, and many doctests.
 

src/sage/rings/complex_mpfr.pyx

@@ -1,5 +1,5 @@
 """
-Arbitrary Precision Floating Point Complex Numbers
+Arbitrary precision floating point complex numbers using GNU MPFR
 
 AUTHORS:
 

src/sage/rings/real_double.pyx

@@ -1,5 +1,5 @@
 r"""
-Double Precision Real Numbers
+Double precision floating point real numbers
 
 EXAMPLES:
 

src/sage/rings/real_mpfi.pyx

@@ -1,5 +1,5 @@
 r"""
-Arbitrary Precision Real Intervals
+Arbitrary precision real intervals using MPFI
 
 AUTHORS:
 
@@ -16,8 +16,8 @@ AUTHORS:
 
 - Travis Scrimshaw (2012-11-02): Added doctests for full coverage
 
-This is a straightforward binding to the MPFI library; it may be
-useful to refer to its documentation for more details.
+This is a straightforward binding to the :ref:`MPFI library <spkg_mpfi>`;
+it may be useful to refer to its documentation for more details.
 
 An interval is represented as a pair of floating-point numbers `a`
 and `b` (where `a \leq b`) and is printed as a standard floating-point

src/sage/rings/real_mpfr.pyx

@@ -1,5 +1,5 @@
 r"""
-Arbitrary Precision Real Numbers
+Arbitrary precision floating point real numbers using GNU MPFR
 
 AUTHORS: