def toLatLon(self, LatLon, datum=None, **LatLon_kwds): '''Convert this WM coordinate to a geodetic point. @arg LatLon: Ellipsoidal class to return the geodetic point (C{LatLon}). @kwarg datum: Optional datum for ellipsoidal or C{None} for spherical B{C{LatLon}} (C{Datum}). @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments. @return: Point of this WM coordinate (B{C{LatLon}}). @raise TypeError: If B{C{LatLon}} and B{C{datum}} are incompatible or if B{C{datum}} is invalid or not ellipsoidal. @example: >>> w = Wm(448251.795, 5411932.678) >>> from pygeodesy import sphericalTrigonometry as sT >>> ll = w.toLatLon(sT.LatLon) # 43°39′11.58″N, 004°01′36.17″E ''' e = issubclassof(LatLon, _LLEB) if e and datum: kwds = _xkwds(LatLon_kwds, datum=datum) elif not (e or datum): # and LatLon kwds = LatLon_kwds datum = None else: raise _TypeError(LatLon=LatLon, datum=datum) r = self.latlon2(datum=datum) r = LatLon(r.lat, r.lon, **kwds) return self._xnamed(r)
def __imul__(self, other): '''Multiply this instance by a scalar or an other instance. @arg other: L{Fsum} instance or C{scalar}. @return: This instance, updated (L{Fsum}). @raise TypeError: Invalid B{C{other}} type. @see: Method L{Fsum.fmul}. ''' if isscalar(other): self.fmul(other) elif isinstance(other, Fsum): ps = list(other._ps) # copy if ps: s = self.fcopy() self.fmul(ps.pop()) while ps: # self += s * ps.pop() p = s.fcopy() p.fmul(ps.pop()) self.fadd(p._ps) else: self._ps = [] # zero self._fsum2_ = None else: raise _TypeError(_SPACE_(self, '*=', repr(other))) return self
def __mod__(self, arg, **unused): '''Regular C{%} operator. @arg arg: A C{scalar} value to be formatted (either the C{scalar}, or a 1-tuple C{(scalar,)}, or 2-tuple C{(prec, scalar)}. @raise TypeError: Non-scalar B{C{arg}} value. @raise ValueError: Invalid B{C{arg}}. ''' def _error(arg): n = _DOT_(Fstr.__name__, self.name or self) return _SPACE_(n, _PERCENT_, repr(arg)) prec = 6 # default std %f and %F if isinstance(arg, (tuple, list)): n = len(arg) if n == 1: arg = arg[0] elif n == 2: prec, arg = arg else: raise _ValueError(_error(arg)) if not isscalar(arg): raise _TypeError(_error(arg)) return self(arg, prec=prec)
def __delattr__(self, name): if name in self._Names_: raise _TypeError('del', _dot_(self.classname, name), txt=_immutable_) elif name in (_name_, _name): _Named.__setattr__(self, name, '') # XXX _Named.name.fset(self, '') else: tuple.__delattr__(self, name)
def __setattr__(self, name, value): if name in self._Names_: raise _TypeError(_dot_(self.classname, name), value, txt=_immutable_) elif name in (_name_, _name): _Named.__setattr__(self, name, value) # XXX _Named.name.fset(self, value) else: tuple.__setattr__(self, name, value)
def _ll2datum(ll, datum, name): '''(INTERNAL) Convert datum if needed. ''' if datum not in (None, ll.datum): try: ll = ll.convertDatum(datum) except AttributeError: raise _TypeError(name, ll, txt=_item_ps(_no_convertDatum_, datum.name)) return ll
def freduce(f, iterable, *start): '''For missing C{functools.reduce}. ''' if start: r = v = start[0] else: r, v = 0, MISSING for v in iterable: r = f(r, v) if v is MISSING: raise _TypeError(iterable=(), start=MISSING) return r
def __setattr__(self, name, value): '''Set attribute or item B{C{name}} to B{C{value}}. ''' if name in self._Names_: raise _TypeError(_DOT_(self.classname, name), value, txt=_immutable_) elif name in (_name_, _name): _Named.__setattr__(self, name, value) # XXX _Named.name.fset(self, value) else: tuple.__setattr__(self, name, value)
def __new__(cls, *args): '''New L{_NamedTuple} initialized with B{C{positional}} arguments. ''' self = tuple.__new__(cls, args) ns = self._Names_ if not (isinstance(ns, tuple) and len(ns) > 1): # XXX > 0 raise _TypeError(_dot_(self.classname, _Names_), ns) if len(ns) != len(args) or not ns: raise LenError(cls, args=len(args), ns=len(ns)) if _name_ in ns: t = unstr(_dot_(self.classname, _Names_), *ns) raise _NameError(_name_, _name_, txt=t) return self
def _latlon3(self, LatLon, datum): '''(INTERNAL) Convert cached LatLon ''' ll = self._latlon if LatLon is None: if datum and datum != ll.datum: raise _TypeError(latlon=ll, txt=_item_ps(_no_convertDatum_, datum.name)) return _xnamed(LatLonDatum3Tuple(ll.lat, ll.lon, ll.datum), ll.name) else: _xsubclassof(_LLEB, LatLon=LatLon) ll = _xnamed(LatLon(ll.lat, ll.lon, datum=ll.datum), ll.name) return _ll2datum(ll, datum, _LatLon_)
def __delattr__(self, name): '''Delete an attribute by B{C{name}}. @note: Items can not be deleted. ''' if name in self._Names_: raise _TypeError(_del_, _DOT_(self.classname, name), txt=_immutable_) elif name in (_name_, _name): _Named.__setattr__(self, name, NN) # XXX _Named.name.fset(self, NN) else: tuple.__delattr__(self, name)
def _validate(self, _OK=False): # see .EcefMatrix '''(INTERNAL) One-time check of C{_Names_} and C{_Units_} for each C{_NamedUnit} I{sub-class separately}. ''' ns = self._Names_ if not (isinstance(ns, tuple) and len(ns) > 1): # XXX > 0 raise _TypeError(_DOT_(self.classname, _Names_), ns) for i, n in enumerate(ns): if not _xvalid(n, _OK=_OK): t = Fmt.SQUARE(_Names_, i) raise _ValueError(_DOT_(self.classname, t), n) us = self._Units_ if not isinstance(us, tuple): raise _TypeError(_DOT_(self.classname, _Units_), us) if len(us) != len(ns): raise LenError(self.__class__, _Units_=len(us), _Names_=len(ns)) for i, u in enumerate(us): if not (u is None or callable(u)): t = Fmt.SQUARE(_Units_, i) raise _TypeError(_DOT_(self.classname, t), u) self.__class__._validated = True
def others(self, other, name=_other_, up=1): # see .points.LatLon_.others '''Check this and an other instance for type compatiblility. @arg other: The other instance (any C{type}). @kwarg name: Optional, name for other (C{str}). @kwarg up: Number of call stack frames up (C{int}). @raise TypeError: Mismatch of the B{C{other}} and this C{class} or C{type}. ''' if not (isinstance(self, other.__class__) or isinstance(other, self.__class__)): n = _callname(name, classname(self, prefixed=True), self.name, up=up + 1) raise _TypeError(name, other, txt=_incompatible(n))
def __iadd__(self, other): '''Add a scalar or an other instance to this instance. @arg other: L{Fsum} instance or C{scalar}. @return: This instance, updated (L{Fsum}). @raise TypeError: Invalid B{C{other}} type. @see: Method L{Fsum.fadd}. ''' if isscalar(other): self.fadd_(other) elif other is self: self.fmul(2) elif isinstance(other, Fsum): self.fadd(other._ps) else: raise _TypeError(_SPACE_(self, '+=', repr(other))) return self
def __isub__(self, other): '''Subtract a scalar or an other instance from this instance. @arg other: L{Fsum} instance or C{scalar}. @return: This instance, updated (L{Fsum}). @raise TypeError: Invalid B{C{other}} type. @see: Method L{Fsum.fadd}. ''' if isscalar(other): self.fadd_(-other) elif other is self: self._ps = [] # zero self._fsum2_ = None elif isinstance(other, Fsum): self.fadd(-p for p in other._ps) else: raise _TypeError(_SPACE_(self, '-=', repr(other))) return self
def _xotherError(inst, other, name=_other_, up=1): '''(INTERNAL) Return a C{_TypeError} for an incompatible, named C{other}. ''' n = _callname(name, classname(inst, prefixed=True), inst.name, up=up + 1) return _TypeError(name, other, txt=_incompatible(n))
def __setattr__(self, attr, value): # PYCHOK no cover from pygeodesy.errors import _TypeError t = _EQUALSPACED_(self._DOT_(attr), value) raise _TypeError(t, txt=_immutable_)
def _2epoch(epoch): # imported by .ellipsoidalBase '''(INTERNAL) Validate an C{epoch}. ''' if isscalar(epoch) and epoch > 0: # XXX 1970? return _F(epoch) raise _TypeError(epoch=epoch, txt=_not_scalar_)