Cleanup API docs and CHANGELOG

Author: juntyr

quaddtype/docs/api/constants_api.md

@@ -7,50 +7,50 @@ Pre-defined mathematical constants with quad precision accuracy.
 ```{eval-rst}
 .. data:: numpy_quaddtype.pi
 
-   The mathematical constant π (pi).
-   
+   The mathematical constant :math:`pi` (pi).
+
    Value: 3.14159265358979323846264338327950288...
-   
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.e
 
-   Euler's number, the base of natural logarithms.
-   
+   Euler's number :math:`e`, the base of natural logarithms.
+
    Value: 2.71828182845904523536028747135266249...
-   
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.log2e
 
-   The base-2 logarithm of e: log₂(e).
-   
+   The base-2 logarithm of :math:`e`: :math:`\log_{2}{e}`.
+
    Value: 1.44269504088896340735992468100189213...
-   
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.log10e
 
-   The base-10 logarithm of e: log₁₀(e).
-   
+   The base-10 logarithm of :math:`e`: :math:`\log_{10}{e}`.
+
    Value: 0.43429448190325182765112891891660508...
-   
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.ln2
 
-   The natural logarithm of 2: ln(2).
-   
+   The natural logarithm of 2: :math:`\ln(2)`.
+
    Value: 0.69314718055994530941723212145817656...
-   
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.ln10
 
-   The natural logarithm of 10: ln(10).
-   
+   The natural logarithm of 10: :math:`\ln(10)`.
+
    Value: 2.30258509299404568401799145468436420...
-   
+
    :type: QuadPrecision
 ```
 
@@ -59,38 +59,44 @@ Pre-defined mathematical constants with quad precision accuracy.
 ```{eval-rst}
 .. data:: numpy_quaddtype.epsilon
 
-   Machine epsilon: the smallest positive number such that 1.0 + epsilon ≠ 1.0.
-   
-   Approximately 1.93 × 10⁻³⁴.
-   
+   Machine epsilon: the smallest positive number such that :math:`1.0 + \epsilon \neq 1.0`.
+
+   :math:`2^{-112}` or approximately :math:`1.93 \cdot 10^{-34}`.
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.max_value
 
    The largest representable finite quad-precision value.
-   
-   Approximately 1.19 × 10⁴⁹³².
-   
+
+   :math:`216383 \cdot (2 - 2^{-112})` or approximately :math:`1.19 \cdot 10^{4932}`.
+
+   The largest negative representable finite quad-precision value is `-numpy_quaddtype.max_value`.
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.smallest_normal
 
-   The smallest positive normalized quad-precision value.
-   
-   Approximately 3.36 × 10⁻⁴⁹³².
-   
+   The smallest positive normal (normalized, mantissa has a leading 1 bit) quad-precision value.
+
+   :math:`2^{-16382} \cdot (1 - 2^{-112})` or approximately :math:`3.36 \cdot 10^{-4932}`.
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.smallest_subnormal
 
-   The smallest positive subnormal (denormalized) quad-precision value.
-   
+   The smallest positive subnormal (denormalized, mantissa has a leading 0 bit) quad-precision value.
+
+   :math:`2^{-16494}` or approximately :math:`6.48 \cdot 10^{-4966}`.
+
    :type: QuadPrecision
 
 .. data:: numpy_quaddtype.resolution
 
-   The approximate decimal resolution of quad precision.
-   
+   The approximate decimal resolution of quad precision, i.e. `10 ** (-precision)`.
+
+   :math:`10^{-33}`.
+
    :type: QuadPrecision
 ```
 
@@ -99,15 +105,15 @@ Pre-defined mathematical constants with quad precision accuracy.
 ```{eval-rst}
 .. data:: numpy_quaddtype.bits
 
-   Total number of bits in quad precision representation.
-   
+   The total number of bits in quad precision representation.
+
    :value: 128
    :type: int
 
 .. data:: numpy_quaddtype.precision
 
-   Approximate number of significant decimal digits.
-   
+   The approximate number of significant decimal digits.
+
    :value: 33
    :type: int
 ```
@@ -130,7 +136,7 @@ import numpy as np
 from numpy_quaddtype import QuadPrecDType
 
 # e^(ln2) should equal 2
-two = np.exp(np.array([ln2]))[0]
+two = np.exp(np.array(ln2))
 print(f"e^(ln2) = {two}")
 
 # log2(e) * ln(2) should equal 1

quaddtype/docs/api/core.md

@@ -8,58 +8,58 @@ The fundamental types provided by NumPy QuadDType.
 .. class:: numpy_quaddtype.QuadPrecision(value, backend="sleef")
 
    A quad-precision (128-bit) floating-point scalar.
-   
+
    QuadPrecision is a NumPy scalar type that provides IEEE 754 binary128
    floating-point arithmetic. It can be used standalone or as elements
    of NumPy arrays.
-   
-   :param value: The value to convert to quad precision. Can be:
-       
+
+   :param value: The value to convert to quad precision. It can be:
+
        - ``float`` or ``int``: Python numeric types
        - ``str``: String representation for maximum precision
        - ``bytes``: Raw 16-byte representation
        - ``numpy.floating`` or ``numpy.integer``: NumPy numeric types
        - ``QuadPrecision``: Another QuadPrecision value
-       
    :type value: float, int, str, bytes, numpy scalar, or QuadPrecision
+
    :param backend: Computation backend to use. Either ``"sleef"`` (default) 
        or ``"longdouble"``.
    :type backend: str, optional
-   
+
    **Examples**
-   
+
    Create from different input types::
-   
+
        >>> from numpy_quaddtype import QuadPrecision
        >>> QuadPrecision(3.14)
        QuadPrecision('3.14000000000000012434...')
        >>> QuadPrecision("3.14159265358979323846264338327950288")
        QuadPrecision('3.14159265358979323846264338327950288')
        >>> QuadPrecision(42)
        QuadPrecision('42.0')
-   
+
    Arithmetic operations::
-   
+
        >>> x = QuadPrecision("1.5")
        >>> y = QuadPrecision("2.5")
        >>> x + y
        QuadPrecision('4.0')
        >>> x * y
        QuadPrecision('3.75')
-   
+
    .. attribute:: dtype
       :type: QuadPrecDType
-      
+
       The NumPy dtype for this scalar.
-   
+
    .. attribute:: real
       :type: QuadPrecision
-      
-      The real part (returns self for real numbers).
-   
+
+      The real part (always self for QuadPrecision).
+
    .. attribute:: imag
       :type: QuadPrecision
-      
+
       The imaginary part (always zero for QuadPrecision).
 ```
 
@@ -69,45 +69,45 @@ The fundamental types provided by NumPy QuadDType.
 .. class:: numpy_quaddtype.QuadPrecDType(backend="sleef")
 
    NumPy dtype for quad-precision floating-point arrays.
-   
-   QuadPrecDType is a custom NumPy dtype that enables creation and
+
+   QuadPrecDType is a custom NumPy dtype that enables the creation and
    manipulation of arrays containing quad-precision values.
-   
+
    :param backend: Computation backend. Either ``"sleef"`` (default) or
        ``"longdouble"``.
    :type backend: str, optional
-   
+
    **Examples**
-   
+
    Create arrays with QuadPrecDType::
-   
+
        >>> import numpy as np
        >>> from numpy_quaddtype import QuadPrecDType
        >>> arr = np.array([1, 2, 3], dtype=QuadPrecDType())
        >>> arr.dtype
        QuadPrecDType128
        >>> np.zeros(5, dtype=QuadPrecDType())
        array([0.0, 0.0, 0.0, 0.0, 0.0], dtype=QuadPrecDType128)
-   
+
    .. attribute:: backend
       :type: QuadBackend
-      
-      The computation backend (SLEEF or LONGDOUBLE).
-   
+
+      The computation backend (``QuadBackend.SLEEF`` or ``QuadBackend.LONGDOUBLE``).
+
    .. attribute:: itemsize
       :type: int
-      
-      Size of each element in bytes (always 16).
-   
+
+      The size of each element in bytes (always 16).
+
    .. attribute:: alignment
       :type: int
-      
-      Memory alignment in bytes (always 16).
-   
+
+      The memory alignment in bytes (always 16).
+
    .. attribute:: name
       :type: str
-      
-      String name of the dtype (``"QuadPrecDType128"``).
+
+      The string name of the dtype (``"QuadPrecDType128"``).
 ```
 
 ## QuadBackend
@@ -116,22 +116,22 @@ The fundamental types provided by NumPy QuadDType.
 .. class:: numpy_quaddtype.QuadBackend
 
    Enumeration of available computation backends.
-   
+
    .. attribute:: SLEEF
       :value: 0
-      
+
       SLEEF library backend (default). Provides true IEEE 754 binary128
       quad precision with SIMD optimization.
-   
+
    .. attribute:: LONGDOUBLE
       :value: 1
-      
-      Platform's native long double backend. Precision varies by platform.
-   
+
+      The platform's native long double backend. The precision varies by platform.
+
    **Example**
-   
+
    ::
-   
+
        >>> from numpy_quaddtype import QuadPrecDType, QuadBackend
        >>> dtype = QuadPrecDType()
        >>> dtype.backend == QuadBackend.SLEEF
@@ -146,9 +146,9 @@ The fundamental types provided by NumPy QuadDType.
 .. function:: numpy_quaddtype.SleefQuadPrecision(value)
 
    Create a QuadPrecision scalar using the SLEEF backend.
-   
+
    Equivalent to ``QuadPrecision(value, backend="sleef")``.
-   
+
    :param value: Value to convert to quad precision.
    :return: Quad precision scalar using SLEEF backend.
    :rtype: QuadPrecision
@@ -160,9 +160,9 @@ The fundamental types provided by NumPy QuadDType.
 .. function:: numpy_quaddtype.LongDoubleQuadPrecision(value)
 
    Create a QuadPrecision scalar using the longdouble backend.
-   
+
    Equivalent to ``QuadPrecision(value, backend="longdouble")``.
-   
+
    :param value: Value to convert to quad precision.
    :return: Quad precision scalar using longdouble backend.
    :rtype: QuadPrecision
@@ -174,9 +174,9 @@ The fundamental types provided by NumPy QuadDType.
 .. function:: numpy_quaddtype.SleefQuadPrecDType()
 
    Create a QuadPrecDType using the SLEEF backend.
-   
+
    Equivalent to ``QuadPrecDType(backend="sleef")``.
-   
+
    :return: Dtype for SLEEF-backed quad precision arrays.
    :rtype: QuadPrecDType
 ```
@@ -187,9 +187,9 @@ The fundamental types provided by NumPy QuadDType.
 .. function:: numpy_quaddtype.LongDoubleQuadPrecDType()
 
    Create a QuadPrecDType using the longdouble backend.
-   
+
    Equivalent to ``QuadPrecDType(backend="longdouble")``.
-   
+
    :return: Dtype for longdouble-backed quad precision arrays.
    :rtype: QuadPrecDType
 ```