pygeodesy 24.5.15__py2.py3-none-any.whl → 24.6.1__py2.py3-none-any.whl

pygeodesy/fmath.py

@@ -12,7 +12,7 @@ from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _N_1_0, _1_5, _copysign_0_0, _isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
-                             _xError, _xkwds_get, _xkwds_pop2
+                             _xError, _xkwds_get1, _xkwds_pop2
 from pygeodesy.fsums import _2float, Fsum, fsum, fsum1_, _isFsumTuple, _1primed, \
                              Fmt, unstr
 from pygeodesy.interns import MISSING, _negative_, _not_scalar_
@@ -24,7 +24,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.05.10'
+__version__ = '24.05.29'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
@@ -39,12 +39,13 @@ class Fdot(Fsum):
         '''New L{Fdot} precision dot product M{sum(a[i] * b[i] for
            i=0..len(a)-1)}.
 
-           @arg a: Iterable of values (each C{scalar} or an L{Fsum} or
-                   L{Fsum2Tuple} instance).
-           @arg b: Other values (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
-                   instance), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=0.0}
-                       threshold, see L{Fsum<Fsum.__init__>}.
+           @arg a: Iterable of values (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
+                   instance).
+           @arg b: Other values (each C{scalar} or an L{Fsum} or L{Fsum2Tuple} instance),
+                   all positional.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} (C{str}) and the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) for raising L{ResidualError}s, see class
+                       L{Fsum<Fsum.__init__>}.
 
            @raise LenError: Unequal C{len(B{a})} and C{len(B{b})}.
 
@@ -68,10 +69,11 @@ class Fhorner(Fsum):
            i=0..len(cs)-1)}.
 
            @arg x: Polynomial argument (C{scalar} or an L{Fsum} or L{Fsum2Tuple}).
-           @arg cs: Polynomial coeffients (each C{scalar} or an L{Fsum} or
-                    L{Fsum2Tuple} instance), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=0.0}
-                       threshold, see L{Fsum<Fsum.__init__>}.
+           @arg cs: Polynomial coeffients (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
+                    instance), all positional.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} (C{str}) and the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) for raising L{ResidualError}s, see class
+                       L{Fsum<Fsum.__init__>}.
 
            @raise OverflowError: Partial C{2sum} overflow.
 
@@ -83,19 +85,7 @@ class Fhorner(Fsum):
         '''
         Fsum.__init__(self, **name_RESIDUAL)
         if cs:
-            if _isFsumTuple(x):
-                _mul = self._mul_Fsum
-            else:
-                _mul = self._mul_scalar
-                x = _2float(x=x)
-            op = Fhorner.__name__
-            if len(cs) > 1 and x:
-                for c in reversed(cs):
-                    self._fset_ps(_mul(x, op))
-                    self._fadd(c, op, up=False)
-                self._update()
-            else:  # x == 0
-                self._fadd(cs[0], op)
+            self._fhorner(x, cs, Fhorner.__name__)
         else:
             self._fset_ps(_0_0)
 
@@ -107,11 +97,12 @@ class Fhypot(Fsum):
         '''New L{Fhypot} hypotenuse of (the I{root} of) several components
            (raised to the power I{root}).
 
-           @arg xs: Components (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
-                    instance), all positional.
-           @kwarg root_name_RESIDUAL_raiser: Optional, exponent and C{B{root}=2}
-                       order, C{B{name}=NN}, C{B{RESIDUAL}=0.0} threshold and
-                       C{B{raiser}=True}, see class L{Fsum<Fsum.__init__>} and
+           @arg xs: Components (each C{scalar} or an L{Fsum} or L{Fsum2Tuple} instance),
+                    all positional.
+           @kwarg root_name_RESIDUAL_raiser: Optional, exponent and C{B{root}=2} order
+                       (C{scalar}), C{B{name}=NN} (C{str}), the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) and C{B{raiser}=True} (C{bool}) for
+                       raising L{ResidualError}s, see class L{Fsum<Fsum.__init__>} and
                        method L{root<Fsum.root>}.
         '''
         r = None  # _xkwds_pop2 error
@@ -134,10 +125,11 @@ class Fpolynomial(Fsum):
            M{sum(cs[i] * x**i for i=0..len(cs)-1)}.
 
            @arg x: Polynomial argument (C{scalar} or an L{Fsum} or L{Fsum2Tuple}).
-           @arg cs: Polynomial coeffients (each C{scalar} or an L{Fsum} or
-                    L{Fsum2Tuple} instance), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=0.0}
-                       threshold, see L{Fsum<Fsum.__init__>}.
+           @arg cs: Polynomial coeffients (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
+                    instance), all positional.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} (C{str}) and the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) for raising L{ResidualError}s, see class
+                       L{Fsum<Fsum.__init__>}.
 
            @raise OverflowError: Partial C{2sum} overflow.
 
@@ -162,11 +154,12 @@ class Fpowers(Fsum):
         '''New L{Fpowers} sum of (the I{power} of) several bases.
 
            @arg power: The exponent (C{scalar} or an L{Fsum} or L{Fsum2Tuple}).
-           @arg xs: One or more bases (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
-                    instance), all positional.
-           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN}, C{B{RESIDUAL}=0.0}
-                       threshold and C{B{raiser}=True}, see L{Fsum<Fsum.__init__>}
-                       and L{fpow<Fsum.fpow>}.
+           @arg xs: One or more bases (each C{scalar} or an L{Fsum} or L{Fsum2Tuple} instance),
+                    all positional.
+           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN} (C{str}), the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) and C{B{raiser}=True} (C{bool}) for raising
+                       L{ResidualError}s, see class L{Fsum<Fsum.__init__>} and method
+                       L{fpow<Fsum.fpow>}.
         '''
         try:
             raiser = _Fsum__init__(self, **name_RESIDUAL_raiser)
@@ -183,11 +176,12 @@ class Froot(Fsum):
         '''New L{Froot} root of a precision sum.
 
            @arg root: The order (C{scalar} or an L{Fsum} or L{Fsum2Tuple}), non-zero.
-           @arg xs: Items to summate (each a C{scalar} or an L{Fsum} or L{Fsum2Tuple}
-                    instance), all positional.
-           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN}, C{B{RESIDUAL}=0.0}
-                       threshold and C{B{raiser}=True}, see L{Fsum<Fsum.__init__>}
-                       and L{fpow<Fsum.fpow>}.
+           @arg xs: Items to summate (each a C{scalar} or an L{Fsum} or L{Fsum2Tuple} instance),
+                    all positional.
+           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN} (C{str}), the C{B{RESIDUAL}=0.0}
+                       threshold (C{scalar}) and C{B{raiser}=True} (C{bool}) for raising
+                       L{ResidualError}s, see class L{Fsum<Fsum.__init__>} and method
+                       L{fpow<Fsum.fpow>}.
         '''
         try:
             raiser = _Fsum__init__(self, **name_RESIDUAL_raiser)
@@ -337,8 +331,9 @@ def facos1(x):
     if a < EPS0:
         r = PI_2
     elif a < EPS1:
-        H = Fhorner(-a, 1.5707288, 0.2121144, 0.0742610, 0.0187293)
-        r = float(H * sqrt(_1_0 - a))
+        H  = Fhorner(-a, 1.5707288, 0.2121144, 0.0742610, 0.0187293)
+        H *= Fsqrt(_1_0, -a)
+        r  = float(H)
         if x < 0:
             r = PI - r
     else:
@@ -370,7 +365,7 @@ def fatan(x):
 
 
 def fatan1(x):
-    '''Fast approximation of C{atan(B{x})} for C{0 <= B{x} <= 1}, I{unchecked}.
+    '''Fast approximation of C{atan(B{x})} for C{0 <= B{x} < 1}, I{unchecked}.
 
        @see: U{ShaderFastLibs.h<https://GitHub.com/michaldrobot/ShaderFastLibs/
              blob/master/ShaderFastMathLib.h>} and U{Efficient approximations
@@ -379,7 +374,7 @@ def fatan1(x):
              IEEE Signal Processing Magazine, 111, May 2006.
     '''
     # Eq (9): PI_4 * x - x * (abs(x) - 1) * (0.2447 + 0.0663 * abs(x)), for -1 < x < 1
-    #         PI_4 * x - (x**2 - x) * (0.2447 + 0.0663 * x), for 0 < x - 1
+    #         PI_4 * x - (x**2 - x) * (0.2447 + 0.0663 * x), for 0 < x < 1
     #         x * (1.0300981633974482 + x * (-0.1784 - x * 0.0663))
     H = Fhorner(x, _0_0, 1.0300981634, -0.1784, -0.0663)
     return float(H)
@@ -591,7 +586,7 @@ def fpolynomial(x, *cs, **over):
        @see: Class L{Fpolynomial} for further details.
     '''
     P =  Fpolynomial(x, *cs)
-    d = _xkwds_get(over, over=0) if over else 0
+    d = _xkwds_get1(over, over=0) if over else 0
     return P.fover(d) if d else float(P)