Add elliptic functions..

rocky · rocky · commit 71081e7f258a · 2022-07-27T08:36:29.000-04:00
Revise a few gamma fns.
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -19,12 +19,15 @@ Enhancements
 * Pyston up to versions from 2.2 to 2.3.4 are supported as are PyPy versions from 3.7-7.3.9.0 up 3.9-7.3.9. However those Python interpreters may have limitations and limitations on packages that they support.
 * Compatibility with the default way in which WMA sorts expressions was improved: Now expressions with fewer elements come first (issue #458).
 
-  
+
 Documentation
 .............
 
 * "Testing Expressions" section added
 * "Representation of Numbers" section added
+* "Descriptive Statistics" section added and "Moments" folded into that
+* Many More URL references
+* Chapter and Sections are now in alphabetical order
 
 New Builtins
 ============
@@ -34,6 +37,10 @@ New Builtins
 * ``CompositeQ``.
 * ``Diagonal``. Issue #115.
 * ``Divisible``.
+* ``EllipticE``
+* ``EllipticF``
+* ``EllipticK``
+* ``EllipticPhi``
 * ``EulerPhi``
 * ``$Echo``. Issue #42.
 * ``FindRoot`` was improved for supporting numerical derivatives Issue #67, as well as the use of scipy libraries when are available.
diff --git a/mathics/builtin/base.py b/mathics/builtin/base.py
@@ -6,8 +6,7 @@
 from functools import total_ordering
 import importlib
 from itertools import chain
-import typing
-from typing import Any, Callable, Iterable, List, Optional, cast
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union, cast
 
 
 from mathics.builtin.exceptions import (
@@ -23,6 +22,7 @@
 )
 from mathics.core.attributes import protected, read_protected, no_attributes
 from mathics.core.convert.expression import to_expression
+from mathics.core.convert.python import from_bool
 from mathics.core.convert.sympy import from_sympy
 from mathics.core.definitions import Definition
 from mathics.core.expression import Expression, SymbolDefault
@@ -35,8 +35,6 @@
     Symbol,
     ensure_context,
     strip_context,
-    SymbolFalse,
-    SymbolTrue,
 )
 from mathics.core.systemsymbols import SymbolHoldForm, SymbolMessageName, SymbolRule
 
@@ -174,15 +172,15 @@ def apply_with_options(x, evaluation, options):
     ```
     """
 
-    name: typing.Optional[str] = None
+    name: Optional[str] = None
     context: str = ""
     abstract: bool = False
     attributes: int = protected
     is_numeric: bool = False
-    rules: typing.Dict[str, Any] = {}
-    formats: typing.Dict[str, Any] = {}
-    messages: typing.Dict[str, Any] = {}
-    options: typing.Dict[str, Any] = {}
+    rules: Dict[str, Any] = {}
+    formats: Dict[str, Any] = {}
+    messages: Dict[str, Any] = {}
+    options: Dict[str, Any] = {}
     defaults = {}
 
     def __new__(cls, *args, **kwargs):
@@ -409,10 +407,10 @@ def get_name(cls, short=False) -> str:
             return shortname
         return cls.context + shortname
 
-    def get_operator(self) -> typing.Optional[str]:
+    def get_operator(self) -> Optional[str]:
         return None
 
-    def get_operator_display(self) -> typing.Optional[str]:
+    def get_operator_display(self) -> Optional[str]:
         return None
 
     def get_functions(self, prefix="apply", is_pymodule=False):
@@ -535,17 +533,17 @@ def get_name(self, short=False) -> str:
 
 
 class Operator(Builtin):
-    operator: typing.Optional[str] = None
-    precedence: typing.Optional[int] = None
+    operator: Optional[str] = None
+    precedence: Optional[int] = None
     precedence_parse = None
     needs_verbatim = False
 
     default_formats = True
 
-    def get_operator(self) -> typing.Optional[str]:
+    def get_operator(self) -> Optional[str]:
         return self.operator
 
-    def get_operator_display(self) -> typing.Optional[str]:
+    def get_operator_display(self) -> Optional[str]:
         if hasattr(self, "operator_display"):
             return self.operator_display
         else:
@@ -561,7 +559,7 @@ def get_functions(self, prefix="apply", is_pymodule=False) -> List[Callable]:
 
 
 class SympyObject(Builtin):
-    sympy_name: typing.Optional[str] = None
+    sympy_name: Optional[str] = None
 
     mathics_to_sympy = {}
 
@@ -574,7 +572,7 @@ def __init__(self, *args, **kwargs):
     def is_constant(self) -> bool:
         return False
 
-    def get_sympy_names(self) -> typing.List[str]:
+    def get_sympy_names(self) -> List[str]:
         if self.sympy_name:
             return [self.sympy_name]
         return []
@@ -657,15 +655,10 @@ def __init__(self, *args, **kwargs):
 
 
 class Test(Builtin):
-    def apply(self, expr, evaluation) -> Symbol:
+    def apply(self, expr, evaluation) -> Optional[Symbol]:
         "%(name)s[expr_]"
-        tst = self.test(expr)
-        if tst:
-            return SymbolTrue
-        elif tst is False:
-            return SymbolFalse
-        else:
-            return
+        test_expr = self.test(expr)
+        return None if test_expr is None else from_bool(bool(test_expr))
 
 
 class SympyFunction(SympyObject):
@@ -905,7 +898,7 @@ def __init__(self, name, count, expected):
 class PatternObject(BuiltinElement, Pattern):
     needs_verbatim = True
 
-    arg_counts: typing.List[int] = []
+    arg_counts: List[int] = []
 
     def init(self, expr):
         super().init(expr)
@@ -968,7 +961,7 @@ class CountableInteger:
     # _support_infinity to False.
     _finite: bool
     _upper_limit: bool
-    _integer: typing.Union[str, int]
+    _integer: Union[str, int]
     _support_infinity = False
 
     def __init__(self, value="Infinity", upper_limit=True):
diff --git a/mathics/builtin/specialfns/elliptic.py b/mathics/builtin/specialfns/elliptic.py
@@ -0,0 +1,144 @@
+"""
+Elliptic Integrals
+
+In integral calculus, an elliptic integral is one of a number of related functions defined as the value of certain integral. Their name originates from their originally arising in connection with the problem of finding the arc length of an ellipse. These funcion often are used in cryptography to encode and decode messages.
+
+See <url>https://en.wikipedia.org/wiki/Elliptic_integral</url>.
+"""
+
+from mathics.core.attributes import (
+    listable as A_LISTABLE,
+    numeric_function as A_NUMERIC_FUNCTION,
+    protected as A_PROTECTED,
+)
+from mathics.builtin.base import SympyFunction
+from mathics.core.convert.sympy import from_sympy
+
+import sympy
+
+
+class EllipticE(SympyFunction):
+    """
+    <dl>
+      <dt>'EllipticE[$m$]'
+      <dd>computes the complete elliptic integral $E$($m$).
+
+      <dt>'EllipticE[ϕ|$m$]'
+      <dd>computes the complete elliptic integral of the second kind $E$($m$|$ϕ$).
+    </dl>
+
+    Elliptic curves give Pi / 2 when evaluated at zero:
+    >> EllipticE[0]
+     = Pi / 2
+
+    >> EllipticE[0.3, 0.8]
+     = 0.296426
+
+    Plot over a reals centered around 0:
+    >> Plot[EllipticE[m], {m, -2, 2}]
+     = -Graphics-
+    """
+
+    attributes = A_NUMERIC_FUNCTION | A_PROTECTED
+    summary_text = "elliptic integral of the second kind E(ϕ|m)"
+    sympy_name = "elliptic_e"
+
+    def apply_m(self, m, evaluation):
+        "%(name)s[m_]"
+        sympy_arg = m.numerify(evaluation).to_sympy()
+        return from_sympy(sympy.elliptic_e(sympy_arg))
+
+    def apply_phi_m(self, phi, m, evaluation):
+        "%(name)s[phi_, m_]"
+        sympy_args = [a.numerify(evaluation).to_sympy() for a in (phi, m)]
+        return from_sympy(sympy.elliptic_e(*sympy_args))
+
+
+class EllipticF(SympyFunction):
+    """
+    <dl>
+      <dt>'EllipticF[$m$]'
+      <dd>computes the elliptic integral of the first kind $F$($ϕ$|$m$).
+    </dl>
+
+    EllipticF is zero when the firt argument is zero:
+    >> EllipticF[0.3, 0.8]
+     = 0.303652
+
+    >> EllipticF[0, 0.8]
+     = 0
+
+    """
+
+    attributes = A_NUMERIC_FUNCTION | A_PROTECTED
+    summary_text = "elliptic integral F(ϕ|m)"
+    sympy_name = "elliptic_f"
+
+    def apply(self, phi, m, evaluation):
+        "%(name)s[phi_, m_]"
+        sympy_args = [a.numerify(evaluation).to_sympy() for a in (phi, m)]
+        return from_sympy(sympy.elliptic_f(*sympy_args))
+
+
+class EllipticK(SympyFunction):
+    """
+    <dl>
+      <dt>'EllipticK[$m$]'
+      <dd>computes the elliptic integral of the first kind $K$($m$).
+    </dl>
+
+    >> EllipticK[0.5]
+     = 1.85407
+
+    Elliptic curves give Pi / 2 when evaluated at zero:
+    >> EllipticK[0]
+     = Pi / 2
+
+    Plot over a reals around 0:
+    >> Plot[EllipticK[n], {n, -1, 1}]
+     = -Graphics-
+    """
+
+    attributes = A_NUMERIC_FUNCTION | A_LISTABLE | A_PROTECTED
+    summary_text = "elliptic integral of the first kind K(m)"
+    sympy_name = "elliptic_k"
+
+    def apply(self, m, evaluation):
+        "%(name)s[m__]"
+        args = m.numerify(evaluation).get_sequence()
+        sympy_args = [a.to_sympy() for a in args]
+        return from_sympy(sympy.elliptic_k(*sympy_args))
+
+
+class EllipticPi(SympyFunction):
+    """
+    <dl>
+      <dt>'EllipticPi[$n$, $m$]'
+      <dd>computes the elliptic integral of the third kind $Pi$($m$).
+    </dl>
+
+    >> EllipticPi[0.4, 0.6]
+     = 2.89281
+
+    Elliptic curves give Pi / 2 when evaluated at zero:
+    >> EllipticPi[0, 0]
+     = Pi / 2
+
+    """
+
+    attributes = A_NUMERIC_FUNCTION | A_PROTECTED
+    summary_text = "elliptic integral of the third kind P(n|m)"
+    sympy_name = "elliptic_pi"
+
+    def apply_n_m(self, n, m, evaluation):
+        "%(name)s[n_, m_]"
+        sympy_n = m.numerify(evaluation).to_sympy()
+        sympy_m = n.numerify(evaluation).to_sympy()
+        return from_sympy(sympy.elliptic_pi(sympy_n, sympy_m))
+
+    def apply_n_phi_m(self, n, phi, m, evaluation):
+        "%(name)s[n_, phi_, m_]"
+        sympy_n = m.numerify(evaluation).to_sympy()
+        sympy_phi = m.numerify(evaluation).to_sympy()
+        sympy_m = n.numerify(evaluation).to_sympy()
+        return from_sympy(sympy.elliptic_pi(sympy_n, sympy_phi, sympy_m))
diff --git a/mathics/builtin/specialfns/gamma.py b/mathics/builtin/specialfns/gamma.py
@@ -17,7 +17,11 @@
     Integer1,
     Number,
 )
-from mathics.core.attributes import listable, numeric_function, protected
+from mathics.core.attributes import (
+    listable as A_LISTABLE,
+    numeric_function as A_NUMERIC_FUNCTION,
+    protected as A_PROTECTED,
+)
 from mathics.core.convert.mpmath import from_mpmath
 from mathics.core.convert.python import from_python
 from mathics.core.convert.sympy import from_sympy
@@ -51,7 +55,7 @@ class Beta(_MPMathMultiFunction):
     """
 
     summary_text = "Euler's Beta function"
-    attributes = listable | numeric_function | protected
+    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
     mpmath_names = {
         2: "beta",  # two arguments
         3: "betainc",  # three arguments
@@ -164,12 +168,12 @@ class Factorial(PostfixOperator, _MPMathFunction):
      = 1
     """
 
-    summary_text = "factorial"
-    attributes = numeric_function | protected
+    attributes = A_NUMERIC_FUNCTION | A_PROTECTED
 
+    mpmath_name = "factorial"
     operator = "!"
     precedence = 610
-    mpmath_name = "factorial"
+    summary_text = "factorial"
 
 
 class Factorial2(PostfixOperator, _MPMathFunction):
@@ -196,7 +200,7 @@ class Factorial2(PostfixOperator, _MPMathFunction):
      = 3.35237
     """
 
-    attributes = numeric_function | protected
+    attributes = A_NUMERIC_FUNCTION | A_PROTECTED
     operator = "!!"
     precedence = 610
     mpmath_name = "fac2"
@@ -394,15 +398,15 @@ class Pochhammer(SympyFunction):
      = 6652800
     """
 
-    attributes = listable | numeric_function | protected
+    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
 
-    sympy_name = "RisingFactorial"
-    summary_text = "Pochhammer's symbols"
     rules = {
         "Pochhammer[a_, n_]": "Gamma[a + n] / Gamma[a]",
         "Derivative[1,0][Pochhammer]": "(Pochhammer[#1, #2]*(-PolyGamma[0, #1] + PolyGamma[0, #1 + #2]))&",
         "Derivative[0,1][Pochhammer]": "(Pochhammer[#1, #2]*PolyGamma[0, #1 + #2])&",
     }
+    summary_text = "Pochhammer's symbols"
+    sympy_name = "RisingFactorial"
 
 
 class PolyGamma(_MPMathMultiFunction):
@@ -422,7 +426,7 @@ class PolyGamma(_MPMathMultiFunction):
     >> PolyGamma[3, 5]
      = -22369 / 3456 + Pi ^ 4 / 15
     """
-    attributes = listable | numeric_function | protected
+    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
 
     mpmath_names = {
         1: "digamma",  # 1 argument
@@ -450,7 +454,7 @@ class StieltjesGamma(SympyFunction):
     ##  = ...
     """
 
-    attributes = listable | numeric_function | protected
+    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
 
     summary_text = "Stieltjes' function"
     sympy_name = "stieltjes"
