pygeodesy 24.3.24__py2.py3-none-any.whl

pygeodesy/auxilats/auxDLat.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+
+u'''Class L{AuxDLat} transcoded to Python from I{Karney}'s C++ class U{DAuxLatitude
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1DAuxLatitude.html>}
+in I{GeographicLib version 2.2+}.
+
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2022-2023) and licensed
+under the MIT/X11 License.  For more information, see the U{GeographicLib
+<https://GeographicLib.SourceForge.io>} documentation.
+'''
+# make sure int/int division yields float quotient, see .basics
+from __future__ import division as _; del _  # PYCHOK semicolon
+
+from pygeodesy.auxilats.auxily import Aux, _Datan, _Dasinh, _Dm, _sc, _sn, \
+                                      atan1, AuxError
+from pygeodesy.auxilats.auxLat import AuxLat,  _ALL_DOCS
+from pygeodesy.basics import map1, _reverange
+from pygeodesy.constants import INF, NAN, isfinite, isinf, isnan, _0_0, _0_5, \
+                               _1_0, _2_0, _N_2_0, _naninf, _over, _1_over
+from pygeodesy.elliptic import Elliptic as _Ef,  Fsum
+# from pygeodesy.errors import AuxError  # from .auxilats.auxily
+# from pygeodesy.fsums import Fsum  # from .elliptic
+# from pygeodesy.lazily import _ALL_DOCS  # from .auxilats.auxLat
+# from pygeodesy.utily import atan1  # from .auxilats.auxily
+
+from math import atan2, cos, sin, sqrt
+
+__all__ = ()
+__version__ = '23.12.01'
+
+
+class AuxDLat(AuxLat):
+    '''Class to compute C{Divided Differences} of I{Auxiliary}
+       latitudes and other C{Divided Differences} needed for
+       L{RhumbAux} and L{RhumbLineAux} calculations.
+    '''
+
+    def CParametric(self, Zeta1, Zeta2):
+        '''Short for C{.Dconvert(Aux.BETA, B{Zeta1}, B{Zeta2})}.
+        '''
+        return self.Dconvert(Aux.BETA, Zeta1, Zeta2)
+
+    def CRectifying(self, Zeta1, Zeta2):
+        '''Short for C{.Dconvert(Aux.MU, B{Zeta1}, B{Zeta2})}.
+        '''
+        return self.Dconvert(Aux.MU, Zeta1, Zeta2)
+
+    def _Datanhee(self, x, y):
+        # atan(e*sn(tphi))/e:
+        #  Datan(e*sn(x),e*sn(y))*Dsn(x,y)/Datan(x,y)
+        # asinh(e1*sn(fm1*tphi)):
+        #  Dasinh(e1*sn(fm1*x)), e1*sn(fm1*y)) *
+        # e1 * Dsn(fm1*x, fm1*y) *fm1 / (e * Datan(x,y))
+        # = Dasinh(e1*sn(fm1*x)), e1*sn(fm1*y)) *
+        #  Dsn(fm1*x, fm1*y) / Datan(x,y)
+        if self.f < 0:
+            e  =  self._e
+            r  = _Datan(e * _sn(x), e * _sn(y))
+        else:
+            x *=  self._fm1
+            y *=  self._fm1
+            e1 =  self._e1
+            r  = _Dasinh(e1 * _sn(x), e1 * _sn(y))
+        return _Dsn(x, y) * r
+
+    def Dconvert(self, auxout, Zeta1, Zeta2):
+        '''I{Divided Difference} of one auxiliary latitude wrt another.
+        '''
+        auxin = Zeta1._AUX
+        # assert Zeta2._AUX == auxin
+        try:
+            if auxout != auxin:
+                cs =  self._coeffs(auxout, auxin)
+                # assert len(cs) == self.ALorder
+                r  = _DClenshaw(True, Zeta1, Zeta2, cs, self.ALorder)
+            else:
+                r  = _1_0
+        except AuxError:  # no _coeffs
+            r = NAN
+        return r
+
+    def DE(self, X, Y):
+        # We assume that X and Y are in [-90d, 90d] and
+        # have the same sign. If not we would include
+        #    if (Xn.y() * Yn.y() < 0)
+        #      return d != 0 ? (E(X) - E(Y)) / d : 1
+        # The general formula fails for x = y = 0d and
+        # x = y = 90d.  Probably this is fixable (the
+        # formula works for other x = y.  But let's
+        # also stipulate that x != y.
+
+        # Make both y positive, so we can do the swap a <-> b trick
+        sx, cx, x =  X._yxr_normalized(True)
+        sy, cy, y =  Y._yxr_normalized(True)
+        k2,     d = -self._e12, (y - x)
+        # Switch prolate to oblate, then use formulas for k2 < 0
+        if self.f < 0:  # XXX and False?
+            sx, cx = cx, sx
+            sy, cy = cy, sy
+            d,  k2 = -d, self._e2
+        # See DLMF: Eqs (19.11.2) and (19.11.4) letting
+        Dt = _Dsin(x, y) * (sx + sy)
+        if Dt:
+            t   = _sxk2y(sx, sy, k2) + _sxk2y(sy, sx, k2)
+            Dt  = _over(Dt, t * (cx + cy))
+            t   =  d * Dt
+            t2  = _1_0 + t**2
+            Dt *= _2_0 / t2
+            sk2 = (d * Dt)**2 * k2
+            d2  = _1_0 - sk2
+            c2  = ((_1_0 - t) * (_1_0 + t) / t2)**2 if t else _1_0
+            # E(z)/sin(z)
+            Dt *= _Ef._RFRD(c2, d2, _1_0, sk2) - k2 * sx * sy
+        return Dt
+
+    def DIsometric(self, Phi1, Phi2):
+        '''I{Divided Difference} of the isometric wrt the geographic latitude.
+        '''
+        tx, ty = Phi1.tan, Phi2.tan
+        if isnan(ty) or isnan(tx):  # PYCHOK no cover
+            r =  NAN
+        elif isinf(ty) or isinf(tx):  # PYCHOK no cover
+            r =  INF
+        else:  # psi = asinh(tan(Phi)) - e^2 * atanhee(tan(Phi))
+            r =  self._Datanhee(tx, ty) * self._e2
+            r = _over(_Dasinh(tx, ty) - r, _Datan(tx, ty))
+        return r
+
+    def DParametric(self, Phi1, Phi2):
+        '''I{Divided Difference} of the parametric wrt the geographic latitude.
+        '''
+        fm1, e2m1 = self._fm1, self._e2m1
+        tx,  ty   = Phi1.tan,  Phi2.tan
+        # DbetaDphi = Datan(fm1*tx, fm1*ty) * fm1 / Datan(tx, ty)
+        # Datan(x, y) =  1 / (1 + x^2)                if x == y
+        #             = (atan1(y) - atan1(x)) / (y-x) if x*y < 0
+        #             =  atan1(y-x, x*y + 1) / (y-x)  if x*y > 0
+        txy = tx * ty
+        if txy < 0 or (isinf(ty) and not tx):
+            _a =  atan1
+            r  = _over(_a(fm1 * ty) - _a(fm1 * tx), _a(ty) - _a(tx))
+        elif tx == ty:  # includes tx = ty = inf
+            if txy > 1:  # == tx**2
+                txy = _1_over(txy)
+                r   =  txy + e2m1
+            else:
+                r   =  txy * e2m1 + _1_0
+            r = _over((txy + _1_0) * fm1, r)
+        else:
+            if txy > 1:
+                tx  = _1_over(tx)
+                ty  = _1_over(ty)
+                txy = _1_over(txy)
+                t   =  txy + e2m1
+            else:
+                t   =  txy * e2m1 + _1_0
+            r =  ty - tx
+            r = _over(atan2(r * fm1, t), atan2(r, txy + _1_0))
+        return r
+
+    def DRectifying(self, Phi1, Phi2):
+        '''I{Divided Difference} of the rectifying wrt the geographic latitude.
+        '''
+        # Stipulate that Phi1 and Phi2 are in [-90d, 90d]
+        x, y = Phi1.toRadians, Phi2.toRadians
+        if y == x:  # isnear0
+            Mu1 = self.Rectifying(Phi1, diff=True)
+            tphi1, r = Phi1.tan, Mu1.diff
+            if isfinite(tphi1):
+                r *= _over(_sc(tphi1), _sc(Mu1.tan))**2
+            else:  # PYCHOK no cover
+                r  = _1_over(r)
+        elif (x * y) < 0:
+            r = _over(self.Rectifying(Phi2).toRadians -
+                      self.Rectifying(Phi1).toRadians, y - x)
+        else:
+            r  = _over(self.b, self.RectifyingRadius(True))
+            r *=  self.DE(*map1(self.Parametric, Phi1, Phi2))
+            r *=  self.DParametric(Phi1, Phi2)
+        return r  # or INF or NAN
+
+
+def _DClenshaw(sinp, Zeta1, Zeta2, cs, K):
+    '''(INTERNAL) I{Divided Difference} of L{AuxLat._Clenshaw}.
+
+        @return: C{float} if B{C{sinp}} otherwise a C{Fsum}.
+    '''
+    s1, c1, r1 = Zeta1._yxr_normalized(False)
+    s2, c2, r2 = Zeta2._yxr_normalized(False)
+    Delta = r2 - r1
+    # Evaluate (Clenshaw(sinp, szeta2, czeta2, cs, K) -
+    #           Clenshaw(sinp, szeta1, czeta1, cs, K)) / Delta
+    #        or f = sin if sinp else cos
+    #           sum(cs[k] * (f((2*k+2) * Zeta2) -
+    #                        f((2*k+2) * Zeta2))) / Delta
+    #
+    # Delta is EITHER 1, giving the plain difference OR (Zeta2 - Zeta1)
+    # in radians, giving the I{Divided Difference}.  Other values will
+    # produce nonsense.
+    #
+    # Suffices a and b denote [1,1], [2,1] elements of matrix/vector
+    cp = cm = c2 * c1
+    t       = s2 * s1
+    cp -= t  # not +
+    cm += t  # not -
+
+    sp = s2 * c1
+    t  = c2 * s1
+    smd = ((sin(Delta) / Delta) if Delta != _1_0 else
+           (sp - t))  if Delta  else _1_0
+    sp += t
+
+    xa = cp * cm  * _2_0
+    xb = sp * smd * _N_2_0
+    xD = xb * Delta**2
+
+    if isfinite(xD) and isfinite(xb) and isfinite(xa):
+        U0a, U1a = Fsum(), Fsum()
+        U0b, U1b = Fsum(), Fsum()
+        for k in _reverange(K):  # assert len(cs) == K
+            # t = x . U0 - U1 + cs[k] * I
+            U1a -= U0a * xa + U0b * xD + cs[k]
+            U1b -= U0a * xb + U0b * xa
+            U1a, U0a = U0a, -U1a
+            U1b, U0b = U0b, -U1b
+        # F0a  = (sp if sinp else  cp) * cm
+        # F0b  = (cp if sinp else -sp) * smd
+        # Fm1a =   0 if sinp else   1  # Fm1b = 0
+        # return (U0b * F0a + U0a * F0b - U1b * Fm1a) * 2
+        if sinp:
+            U1b = _0_0
+        else:
+            sp, cp = cp, -sp
+        U0b *=  sp * cm
+        U0a *=  cp * smd
+        U0a +=  U0b
+        U0a  = _Dm(U0a, U1b, _2_0)
+        r = float(U0a) if sinp else U0a  # Fsum
+    else:
+        r = _naninf(xD, xb, xa)
+    return r
+
+
+def _Dsin(x, y):  # see also .rhumb.ekx._Dsin
+    r = cos((x + y) * _0_5)
+    d =     (x - y) * _0_5
+    if d:
+        r *= sin(d) / d
+    return r
+
+
+def _Dsn(x, y):
+    # (sn(y) - sn(x)) / (y - x)
+    if x != y:
+        snx, sny = _sn(x), _sn(y)
+        if (x * y) > 0:
+            scx, scy = _sc(x), _sc(y)
+            r = _over((snx / scy) + (sny / scx),
+                      (snx + sny) *  scy * scx)
+        else:
+            r = (sny - snx) / (y - x)
+    elif x:
+        r = _1_over(_sc(x) * (x**2 + _1_0))  # == 1 / sqrt3(x**2 + 1)
+    else:
+        r = _1_0
+    return r
+
+
+def _sxk2y(sx, sy, k2):
+    # .DE helper
+    sy *= sy * k2
+    if sy:
+        try:
+            sx *= sqrt(_1_0 - sy)
+        except ValueError:  # domain error
+            sx  = NAN
+    return sx
+
+
+__all__ += _ALL_DOCS(AuxDLat)
+
+# **) MIT License
+#
+# Copyright (C) 2023-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.

pygeodesy/auxilats/auxDST.py

@@ -0,0 +1,296 @@
+
+# -*- coding: utf-8 -*-
+
+u'''Discrete Sine Transforms (AuxDST) in Python, transcoded from I{Karney}'s C++ class
+U{DST<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1DST.html>}
+in I{GeographicLib version 2.2+}.
+
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2022-2023) and licensed
+under the MIT/X11 License.  For more information, see the U{GeographicLib
+<https://GeographicLib.SourceForge.io>} documentation.
+
+@note: Class L{AuxDST} requires U{numpy<https://PyPI.org/project/numpy>} to be
+       installed, version 1.16 or newer.
+'''
+# make sure int/int division yields float quotient, see .basics
+from __future__ import division as _; del _  # PYCHOK semicolon
+
+from pygeodesy.auxilats.auxily import _Dm
+from pygeodesy.basics import isodd, neg, _reverange, _xnumpy
+from pygeodesy.constants import PI_2, PI_4, isfinite, _0_0, _0_5, _naninf
+from pygeodesy.fsums import Fsum,  property_RO
+from pygeodesy.karney import _2cos2x,  _ALL_DOCS
+# from pygeodesy.lazily import _ALL_DOCS  # from .karney
+# from pygeodesy.props import property_RO  # from .fsums
+
+__all__ = ()
+__version__ = '23.12.02'
+
+
+class AuxDST(object):
+    '''Discrete Sine Transforms (DST) for I{Auxiliary} latitudes.
+
+       @see: I{Karney}'s C++ class U{DST
+             <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1DST.html>}.
+    '''
+    _N = 0
+
+    def __init__(self, N):
+        '''New L{AuxDST} instance.
+
+           @arg N: Size, number of points (C{int}).
+        '''
+        if N > 0:
+            self._N = int(N)
+        # kissfft(N, False)  # size, inverse
+
+    @staticmethod
+    def evaluate(sinx, cosx, F, *N):
+        '''Evaluate the Fourier sum given the sine and cosine of the angle,
+           using precision I{Clenshaw} summation.
+
+           @arg sinx: The sin(I{sigma}) (C{float}).
+           @arg cosx: The cos(I{sigma}) (C{float}).
+           @arg F: The Fourier coefficients (C{float}[]).
+           @arg N: Optional, (smaller) number of terms to evaluate (C{int}).
+
+           @return: Precison I{Clenshaw} sum (C{float}).
+
+           @see: Methods C{AuxDST.integral} and C{AuxDST.integral2}.
+        '''
+        a = -_2cos2x(cosx, sinx)
+        if isfinite(a):
+            Y0, Y1 = Fsum(), Fsum()
+            n  = _len_N(F, *N)
+            Fn =  list(F[:n])
+            _F =  Fn.pop
+            if isodd(n):
+                Y0 -= _F()
+            while Fn:  # Y0, Y1 negated
+                Y1 -= Y0 * a + _F()
+                Y0 -= Y1 * a + _F()
+            r = float(_Dm(-Y0, Y1, sinx))
+        else:
+            r = _naninf(-a)
+        return r
+
+    @property_RO
+    def _fft_numpy(self):
+        '''(INTERNAL) Get the C{numpy.fft} module, I{once}.
+        '''
+        AuxDST._fft_numpy = fft = _xnumpy(AuxDST, 1, 16).fft  # overwrite property_RO
+        return fft
+
+    def _fft_real(self, data):
+        '''(INTERNAL) NumPy's I{kissfft}-like C{transform_real} function,
+           taking C{float}[:N] B{C{data}} and returning C{complex}[:N*2].
+        '''
+        # <https://GitHub.com/mborgerding/kissfft/blob/master/test/testkiss.py>
+        return self._fft_numpy.rfftn(data)
+
+    def _ffts(self, data, cIV):
+        '''(INTERNAL) Compute the DST-III or DST-IV FFTransforms.
+
+           @arg data: Elements DST-III[0:N+1] or DST-IV[0:N] (C{float}[])
+                      with DST_III[0] = 0.
+           @arg cIV: If C{True} DST-IV, otherwise DST-III.
+
+           @return: FFTransforms (C{float}[0:N]).
+        '''
+        T, N = (), self.N
+        if N > 0:
+            N2 = N * 2
+            d  = tuple(data)
+            # assert len(d) == N + (0 if cIV else 1)
+
+            if cIV:  # DST-IV
+                from cmath import exp as _cexp
+
+                def _cF(c, j, r=-PI_4 / N):
+                    return c * _cexp(complex(0, r * j))
+
+                i = 0
+            else:  # DST-III
+                i = 1
+                # assert d[0] == _0_0
+
+                def _cF(c, *unused):  # PYCHOK redef
+                    return c
+
+            d += tuple(reversed(d[i:N]))  # i == len(d) - N
+            d += tuple(map(neg, d[:N2]))
+            c  = self._fft_real(d)  # complex[0:N*2]
+            n2 = float(-N2)
+            T  = tuple(_cF(c[j], j).imag / n2 for j in range(1, N2, 2))
+        return T
+
+    def _ffts2(self, data, F):
+        '''(INTERNAL) Doubled FFTransforms.
+
+           @arg data: Grid centers (C{float}[N]).
+           @arg F: The transforms (C{float}[N])
+
+           @return: Doubled FFTransforms (C{float}[N*2]).
+        '''
+        __2 = _0_5  # N = self._N
+        # copy DST-IV order N transform to D[0:N]
+        D = self._ffts(data, True)
+        # assert len(D) == N and len(F) >= N
+        # (DST-IV order N - DST-III order N) / 2
+        M = tuple((d - f) * __2 for d, f in zip(D, F))  # strict=False
+        # (DST-IV order N + DST-III order N) / 2
+        P = tuple((d + f) * __2 for d, f in zip(D, F))  # strict=False
+        # assert len(M) == len(P) == self._N
+        return P + tuple(reversed(M))
+
+    @staticmethod
+    def integral(sinx, cosx, F, *N):
+        '''Evaluate the integral of Fourier sum given the sine and
+           cosine of the angle, using precision I{Clenshaw} summation.
+
+           @arg sinx: The sin(I{sigma}) (C{float}).
+           @arg cosx: The cos(I{sigma}) (C{float}).
+           @arg F: The Fourier coefficients (C{float}[]).
+           @arg N: Optional, C{len(B{F})} or a (smaller) number of
+                   terms to evaluate (C{int}).
+
+           @return: Precison I{Clenshaw} intergral (C{float}).
+
+           @see: Methods C{AuxDST.evaluate} and C{AuxDST.integral2}.
+        '''
+        a = _2cos2x(cosx - sinx, cosx + sinx)
+        if isfinite(a):
+            Y0, Y1 = Fsum(), Fsum()
+            for r in _reverscaled(F, *N):
+                Y1 -= Y0 * a + r
+                Y1, Y0 = Y0, -Y1
+            r = float(_Dm(Y1, Y0, cosx))
+        else:
+            r = _naninf(a)
+        return r
+
+    @staticmethod
+    def integral2(sinx, cosx, siny, cosy, F, *N):  # PYCHOK no cover
+        '''Compute the definite integral of Fourier sum given the
+           sine and cosine of the angles at the end points, using
+           precision I{Clenshaw} summation.
+
+           @arg sinx: The sin(I{sigma1}) (C{float}).
+           @arg cosx: The cos(I{sigma1}) (C{float}).
+           @arg siny: The sin(I{sigma2}) (C{float}).
+           @arg cosy: The cos(I{sigma2}) (C{float}).
+           @arg F: The Fourier coefficients (C{float}[]).
+           @arg N: Optional, C{len(B{F})} or a (smaller) number of
+                   terms to evaluate (C{int}).
+
+           @return: Precison I{Clenshaw} integral (C{float}).
+
+           @see: Methods C{AuxDST.evaluate} and C{AuxDST.integral}.
+        '''
+        #  2 * cos(y - x) * cos(y + x) -> 2 * cos(2 * x)
+        c =  _2cos2x(cosy * cosx, siny * sinx)
+        # -2 * sin(y - x) * sin(y + x) -> 0
+        s = -_2cos2x(siny * cosx, cosy * sinx)
+        if isfinite(c) and isfinite(s):
+            Y0, Y1 = Fsum(), Fsum()
+            Z0, Z1 = Fsum(), Fsum()
+            for r in _reverscaled(F, *N):
+                Y1 -= Y0 * c + Z0 * s + r
+                Z1 -= Y0 * s + Z0 * c
+                Y1, Y0 = Y0, -Y1
+                Z1, Z0 = Z0, -Z1
+            r = float(_Dm(Y1, Y0, cosy - cosx) +
+                      _Dm(Z1, Z0, cosy + cosx))
+        else:
+            r = _naninf(c, s)
+        return r
+
+    @property_RO
+    def N(self):
+        '''Get this DST's size, number of points (C{int}).
+        '''
+        return self._N
+
+    def refine(self, f, F, *sentinel):
+        '''Refine the Fourier series by doubling the sampled points.
+
+           @arg f: Single-argument callable (C{B{f}(sigma)}).
+           @arg F: Initial Fourier series coefficients (C{float}[:N]).
+           @arg sentinel: Optional coefficient(s) to append (C{float}(s)).
+
+           @return: Fourier series coefficients (C{float}[:N*2]).
+
+           @note: Any initial C{B{F}[N:]} sentinel coefficients are ignored.
+        '''
+        def _data(_f, N):  # [:N]
+            if N > 0:
+                r = PI_4 / N
+                for j in range(1, N*2, 2):
+                    yield _f(r * j)
+
+        # F = F[:self.N] handled by zip strict=False in ._ffts2 above
+        return self._ffts2(_data(f, self.N), F) + sentinel
+
+    def reset(self, N):
+        '''Reset this DST.
+
+           @arg N: Size, number of points (C{int}).
+
+           @return: The new size (C{int}, non-negative).
+        '''
+        self._N = N = max(0, N)
+        # kissfft.assign(N*2, False)  # "reset" size, inverse
+        return N
+
+    def transform(self, f):
+        '''Determine C{[N + 1]} terms in the Fourier series.
+
+           @arg f: Single-argument callable (C{B{f}(sigma)}).
+
+           @return: Fourier series coefficients (C{float}[:N+1],
+                    leading 0).
+        '''
+        def _data(_f, N):  # [:N + 1]
+            yield _0_0  # data[0] = 0
+            if N > 0:
+                r = PI_2 / N
+                for i in range(1, N + 1):
+                    yield _f(r * i)
+
+        return self._ffts(_data(f, self.N), False)
+
+
+def _len_N(F, *N):
+    # Adjusted C{len(B{F})}.
+    return min(len(F), *N) if N else len(F)
+
+
+def _reverscaled(F, *N):
+    # Yield F[:N], reversed and scaled
+    for n in _reverange(_len_N(F, *N)):
+        yield F[n] / float(n * 2 + 1)
+
+
+__all__ += _ALL_DOCS(AuxDST)
+
+# **) MIT License
+#
+# Copyright (C) 2023-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.