def _streprs(prec, objs, fmt, ints, force, strepr):
'''(INTERNAL) Helper for C{fstr}, C{pairs}, C{reprs} and C{strs}
'''
# <https://docs.Python.org/3/library/stdtypes.html#printf-style-string-formatting>
if fmt in _FfEeGg:
fGg = fmt in _Gg
fmt = NN(_PERCENT_, _DOT_, abs(prec), fmt)
elif fmt.startswith(_PERCENT_):
fGg = False
try: # to make sure fmt is valid
f = fmt.replace(_DOTSTAR_, Fmt.DOT(abs(prec)))
_ = f % (0.0, )
except (TypeError, ValueError):
raise _ValueError(fmt=fmt, txt=_not_(repr(_DOTSTAR_)))
fmt = f
else:
raise _ValueError(fmt=fmt, txt=_not_(repr(_Fspec_)))
for o in objs:
if force or isinstance(o, float):
t = fmt % (float(o), )
if ints and (isint(o, both=True) or # for ...
# corner case testLcc lon0=-96.0
t.rstrip(_0_).endswith(_DOT_)):
t = t.split(_DOT_)[0]
elif prec > 1:
t = fstrzs(t, ap1z=fGg)
elif strepr:
t = strepr(o)
else:
raise _IsnotError(_scalar_, floats=o)
yield t
def fpowers(x, n, alts=0):
'''Return a series of powers M{[x**i for i=1..n]}.
@arg x: Value (C{scalar}).
@arg n: Highest exponent (C{int}).
@kwarg alts: Only alternating powers, starting with
this exponent (C{int}).
@return: Powers of B{C{x}} (C{float}[]).
@raise TypeError: Non-scalar B{C{x}} or B{C{n}} not C{int}.
@raise ValueError: Non-finite B{C{x}} or non-positive B{C{n}}.
'''
if not isfinite(x):
raise _ValueError(x=x, txt=_not_(_finite_))
if not isint(n):
raise _IsnotError(int.__name__, n=n)
elif n < 1:
raise _ValueError(n=n)
xs = [x]
for _ in range(1, n):
xs.append(xs[-1] * x)
if alts > 0: # x**2, x**4, ...
# XXX PyChecker chokes on xs[alts-1::2]
xs = xs[slice(alts - 1, None, 2)]
# XXX PyChecker claims result is None
return xs
def fadd(self, iterable):
'''Accumulate more values from an iterable.
@arg iterable: Sequence, list, tuple, etc. (C{scalar}s).
@raise OverflowError: Partial C{2sum} overflow.
@raise TypeError: Non-scalar B{C{iterable}} value.
@raise ValueError: Invalid or non-finite B{C{iterable}} value.
'''
if isscalar(iterable): # for backward compatibility
iterable = tuple(iterable)
ps = self._ps
for a in map(float, iterable): # _iter()
if not isfinite(a):
raise _ValueError(iterable=a, txt=_not_(_finite_))
i = 0
for p in ps:
a, p = _2sum(a, p)
if p:
ps[i] = p
i += 1
ps[i:] = [a]
self._n += 1
# assert self._ps is ps
self._fsum2_ = None
def __init__(self, x, *cs):
'''New L{Fpolynomial} evaluation of the polynomial
M{sum(cs[i] * x**i for i=0..len(cs))}.
@arg x: Polynomial argument (C{scalar}).
@arg cs: Polynomial coeffients (C{scalar}[]).
@raise OverflowError: Partial C{2sum} overflow.
@raise TypeError: Non-scalar B{C{x}}.
@raise ValueError: No B{C{cs}} coefficients or B{C{x}} is not finite.
@see: Function L{fpolynomial} and method L{Fsum.fadd}.
'''
if not isfinite(x):
raise _ValueError(x=x, txt=_not_(_finite_))
if not cs:
raise _ValueError(cs=cs, txt=MISSING)
x, cs, xp = float(x), list(cs), _1_0
Fsum.__init__(self, cs.pop(0))
while cs:
xp *= x
self.fadd_(xp * cs.pop(0))
def _lazy_init3(_pygeodesy_):
'''(INTERNAL) Try to initialize lazy import.
@arg _pygeodesy_: The name of the package (C{str}) performing
the imports, to help facilitate resolving
relative imports, usually C{__package__}.
@return: 3-Tuple C{(import_module, package, parent)} of module
C{importlib.import_module}, the importing C{package}
for easy reference within itself, always C{pygeodesy}
and the package name, aka the C{parent}, always
C{'pygeodesy'}.
@raise LazyImportError: Lazy import not supported or not enabled,
an import failed or the package name is
invalid or does not exist.
@note: Global C{isLazy} is set accordingly.
'''
global isLazy
z = _environ.get(_PYGEODESY_LAZY_IMPORT_, None)
if z is None: # _PYGEODESY_LAZY_IMPORT_ not set
isLazy = 1 # ... but on by default on 3.7
else:
z = z.strip() # like PYTHONVERBOSE et.al.
isLazy = int(z) if z.isdigit() else (1 if z else 0)
if isLazy < 1: # not enabled
raise LazyImportError(_PYGEODESY_LAZY_IMPORT_, repr(z), txt=_not_(_enabled_))
if _environ.get('PYTHONVERBOSE', None): # PYCHOK no cover
isLazy += 1
try: # to initialize in Python 3+
from importlib import import_module
package = import_module(_pygeodesy_)
parent = package.__spec__.parent # __spec__ only in Python 3.7+
if parent != _pygeodesy_: # assert
t = _COMMASPACE_(parent, _not_(_pygeodesy_))
raise AttributeError(_EQUALSPACED_('parent', t))
except (AttributeError, ImportError) as x: # PYCHOK no cover
isLazy = False # failed
raise LazyImportError(_lazy_init3.__name__, _pygeodesy_, txt=str(x))
return import_module, package, parent
def _boolkwds(inst, **name_value_pairs): # in .frechet, .hausdorff, .heights
'''(INTERNAL) Set applicable C{bool} properties/attributes.
'''
for n, v in name_value_pairs.items():
b = getattr(inst, n, None)
if b is None: # invalid bool attr
t = _SPACE_(_EQUAL_(n, repr(v)), 'for',
inst.__class__.__name__) # XXX .classname
raise _AttributeError(t, txt=_not_('applicable'))
if v in (False, True) and v != b:
setattr(inst, NN(_UNDER_, n), v)
def _xellipsoidal(**name_value):
'''(INTERNAL) Check an I{ellipsoidal} item.
@return: The B{C{value}} if ellipsoidal.
@raise TypeError: Not ellipsoidal B{C{value}}.
'''
try:
for n, v in name_value.items():
if v.isEllipsoidal:
return v
break
else:
n = v = MISSING
except AttributeError:
pass
raise _TypeError(n, v, txt=_not_(_ellipsoidal_))
def __init__(self, corners, name=__name__):
n, cs = 0, corners
try: # check the clip box/region
n, cs = len2(cs)
if n == 2: # make a box
b, l, t, r = boundsOf(cs, wrap=False)
cs = LL_(b, l), LL_(t, l), LL_(t, r), LL_(b, r)
n, cs = points2(cs, closed=True)
self._cs = cs = cs[:n]
self._nc = n
self._cw = isconvex_(cs, adjust=False, wrap=False)
if not self._cw:
raise ValueError(_not_(_convex_))
if areaOf(cs, adjust=True, radius=1, wrap=True) < EPS:
raise ValueError('near-zero area')
except (PointsError, TypeError, ValueError) as x:
raise ClipError(name, n, cs, txt=str(x))
self.name = name
def fmul(self, factor):
'''Multiple the current, partial sum by a factor.
@arg factor: The multiplier (C{scalar}).
@raise TypeError: Non-scalar B{C{factor}}.
@raise ValueError: Invalid or non-finite B{C{factor}}.
@see: Method L{Fsum.fadd}.
'''
if not isfinite(factor):
raise _ValueError(factor=factor, txt=_not_(_finite_))
f, ps = float(factor), self._ps
if ps: # multiply and adjust partial sums
ps[:] = [p * f for p in ps]
self.fadd_(ps.pop())
self._n -= 1
def __init__(self, name, value, *Types):
t = _not_(_an(_or(*(t.__name__ for t in Types))))
_TypeError.__init__(self, name, value, txt=t)