# -*- coding: utf-8 -*- """ pint.quantity ~~~~~~~~~~~~~ :copyright: 2016 by Pint Authors, see AUTHORS for more details. :license: BSD, see LICENSE for more details. """ from __future__ import division, unicode_literals, print_function, absolute_import import copy import datetime import math import operator import functools import bisect import warnings import numbers import re from .formatting import (remove_custom_flags, siunitx_format_unit, ndarray_to_latex, ndarray_to_latex_parts) from .errors import (DimensionalityError, OffsetUnitCalculusError, UndefinedUnitError, UnitStrippedWarning) from .definitions import UnitDefinition from .compat import string_types, ndarray, np, _to_magnitude, long_type from .util import (PrettyIPython, logger, UnitsContainer, SharedRegistryObject, to_units_container, infer_base_unit, fix_str_conversions) from pint.compat import Loc def _eq(first, second, check_all): """Comparison of scalars and arrays """ out = first == second if check_all and isinstance(out, ndarray): return np.all(out) return out class _Exception(Exception): # pragma: no cover def __init__(self, internal): self.internal = internal def reduce_dimensions(f): def wrapped(self, *args, **kwargs): result = f(self, *args, **kwargs) if result._REGISTRY.auto_reduce_dimensions: return result.to_reduced_units() else: return result return wrapped def ireduce_dimensions(f): def wrapped(self, *args, **kwargs): result = f(self, *args, **kwargs) if result._REGISTRY.auto_reduce_dimensions: result.ito_reduced_units() return result return wrapped def check_implemented(f): def wrapped(self, *args, **kwargs): other=args[0] if other.__class__.__name__ in ["PintArray", "Series"]: return NotImplemented # pandas often gets to arrays of quantities [ Q_(1,"m"), Q_(2,"m")] # and expects Quantity * array[Quantity] should return NotImplemented elif isinstance(other, list) and isinstance(other[0], type(self)): return NotImplemented result = f(self, *args, **kwargs) return result return wrapped @fix_str_conversions class _Quantity(PrettyIPython, SharedRegistryObject): """Implements a class to describe a physical quantity: the product of a numerical value and a unit of measurement. :param value: value of the physical quantity to be created. :type value: str, Quantity or any numeric type. :param units: units of the physical quantity to be created. :type units: UnitsContainer, str or Quantity. """ #: Default formatting string. default_format = '' def __reduce__(self): from . import _build_quantity return _build_quantity, (self.magnitude, self._units) def __new__(cls, value, units=None): if units is None: if isinstance(value, string_types): if value == '': raise ValueError('Expression to parse as Quantity cannot ' 'be an empty string.') inst = cls._REGISTRY.parse_expression(value) return cls.__new__(cls, inst) elif isinstance(value, cls): inst = copy.copy(value) else: inst = object.__new__(cls) inst._magnitude = _to_magnitude(value, inst.force_ndarray) inst._units = UnitsContainer() elif isinstance(units, (UnitsContainer, UnitDefinition)): inst = object.__new__(cls) inst._magnitude = _to_magnitude(value, inst.force_ndarray) inst._units = units elif isinstance(units, string_types): inst = object.__new__(cls) inst._magnitude = _to_magnitude(value, inst.force_ndarray) inst._units = inst._REGISTRY.parse_units(units)._units elif isinstance(units, SharedRegistryObject): if isinstance(units, _Quantity) and units.magnitude != 1: inst = copy.copy(units) logger.warning('Creating new Quantity using a non unity ' 'Quantity as units.') else: inst = object.__new__(cls) inst._units = units._units inst._magnitude = _to_magnitude(value, inst.force_ndarray) else: raise TypeError('units must be of type str, Quantity or ' 'UnitsContainer; not {}.'.format(type(units))) inst.__used = False inst.__handling = None # Only instances where the magnitude is iterable should have __iter__() if hasattr(inst._magnitude,"__iter__"): inst.__iter__ = cls._iter return inst def _iter(self): """ Will be become __iter__() for instances with iterable magnitudes """ # # Allow exception to propagate in case of non-iterable magnitude it_mag = iter(self.magnitude) return iter((self.__class__(mag, self._units) for mag in it_mag)) @property def debug_used(self): return self.__used def __copy__(self): ret = self.__class__(copy.copy(self._magnitude), self._units) ret.__used = self.__used return ret def __deepcopy__(self, memo): ret = self.__class__(copy.deepcopy(self._magnitude, memo), copy.deepcopy(self._units, memo)) ret.__used = self.__used return ret def __str__(self): return format(self) def __repr__(self): return "".format(self._magnitude, self._units) def __hash__(self): self_base = self.to_base_units() if self_base.dimensionless: return hash(self_base.magnitude) else: return hash((self_base.__class__, self_base.magnitude, self_base.units)) _exp_pattern = re.compile(r"([0-9]\.?[0-9]*)e(-?)\+?0*([0-9]+)") def __format__(self, spec): spec = spec or self.default_format if 'L' in spec: allf = plain_allf = r'{}\ {}' else: allf = plain_allf = '{} {}' mstr, ustr = None, None # If Compact is selected, do it at the beginning if '#' in spec: spec = spec.replace('#', '') obj = self.to_compact() else: obj = self # the LaTeX siunitx code if 'Lx' in spec: spec = spec.replace('Lx','') # todo: add support for extracting options opts = '' ustr = siunitx_format_unit(obj.units) allf = r'\SI[%s]{{{}}}{{{}}}'% opts else: ustr = format(obj.units, spec) mspec = remove_custom_flags(spec) if isinstance(self.magnitude, ndarray): if 'L' in spec: mstr = ndarray_to_latex(obj.magnitude, mspec) elif 'H' in spec: # this is required to have the magnitude and unit in the same line allf = r'\[{} {}\]' parts = ndarray_to_latex_parts(obj.magnitude, mspec) if len(parts) > 1: return '\n'.join(allf.format(part, ustr) for part in parts) mstr = parts[0] else: mstr = format(obj.magnitude, mspec).replace('\n', '') else: mstr = format(obj.magnitude, mspec).replace('\n', '') if 'L' in spec: mstr = self._exp_pattern.sub(r"\1\\times 10^{\2\3}", mstr) elif 'H' in spec: mstr = self._exp_pattern.sub(r"\1×10\2\3", mstr) if allf == plain_allf and ustr.startswith('1 /'): # Write e.g. "3 / s" instead of "3 1 / s" ustr = ustr[2:] return allf.format(mstr, ustr).strip() def _repr_pretty_(self, p, cycle): if cycle: super(_Quantity, self)._repr_pretty_(p, cycle) else: p.pretty(self.magnitude) p.text(" ") p.pretty(self.units) def format_babel(self, spec='', **kwspec): spec = spec or self.default_format # standard cases if '#' in spec: spec = spec.replace('#', '') obj = self.to_compact() else: obj = self kwspec = dict(kwspec) if 'length' in kwspec: kwspec['babel_length'] = kwspec.pop('length') kwspec['locale'] = Loc.parse(kwspec['locale']) kwspec['babel_plural_form'] = kwspec['locale'].plural_form(obj.magnitude) return '{} {}'.format( format(obj.magnitude, remove_custom_flags(spec)), obj.units.format_babel(spec, **kwspec)).replace('\n', '') @property def magnitude(self): """Quantity's magnitude. Long form for `m` """ return self._magnitude @property def m(self): """Quantity's magnitude. Short form for `magnitude` """ return self._magnitude def m_as(self, units): """Quantity's magnitude expressed in particular units. :param units: destination units :type units: Quantity, str or dict """ return self.to(units).magnitude @property def units(self): """Quantity's units. Long form for `u` :rtype: UnitContainer """ return self._REGISTRY.Unit(self._units) @property def u(self): """Quantity's units. Short form for `units` :rtype: UnitContainer """ return self._REGISTRY.Unit(self._units) @property def unitless(self): """Return true if the quantity does not have units. """ return not bool(self.to_root_units()._units) @property def dimensionless(self): """Return true if the quantity is dimensionless. """ tmp = self.to_root_units() return not bool(tmp.dimensionality) _dimensionality = None @property def dimensionality(self): """Quantity's dimensionality (e.g. {length: 1, time: -1}) """ if self._dimensionality is None: self._dimensionality = self._REGISTRY._get_dimensionality(self._units) return self._dimensionality def check(self, dimension): """Return true if the quantity's dimension matches passed dimension. """ return self.dimensionality == self._REGISTRY.get_dimensionality(dimension) @classmethod def from_tuple(cls, tup): return cls(tup[0], UnitsContainer(tup[1])) def to_tuple(self): return self.m, tuple(self._units.items()) def compatible_units(self, *contexts): if contexts: with self._REGISTRY.context(*contexts): return self._REGISTRY.get_compatible_units(self._units) return self._REGISTRY.get_compatible_units(self._units) def _convert_magnitude_not_inplace(self, other, *contexts, **ctx_kwargs): if contexts: with self._REGISTRY.context(*contexts, **ctx_kwargs): return self._REGISTRY.convert(self._magnitude, self._units, other) return self._REGISTRY.convert(self._magnitude, self._units, other) def _convert_magnitude(self, other, *contexts, **ctx_kwargs): if contexts: with self._REGISTRY.context(*contexts, **ctx_kwargs): return self._REGISTRY.convert(self._magnitude, self._units, other) return self._REGISTRY.convert(self._magnitude, self._units, other, inplace=isinstance(self._magnitude, ndarray)) def ito(self, other=None, *contexts, **ctx_kwargs): """Inplace rescale to different units. :param other: destination units. :type other: Quantity, str or dict """ other = to_units_container(other, self._REGISTRY) self._magnitude = self._convert_magnitude(other, *contexts, **ctx_kwargs) self._units = other return None def to(self, other=None, *contexts, **ctx_kwargs): """Return Quantity rescaled to different units. :param other: destination units. :type other: Quantity, str or dict """ other = to_units_container(other, self._REGISTRY) magnitude = self._convert_magnitude_not_inplace(other, *contexts, **ctx_kwargs) return self.__class__(magnitude, other) def ito_root_units(self): """Return Quantity rescaled to base units """ _, other = self._REGISTRY._get_root_units(self._units) self._magnitude = self._convert_magnitude(other) self._units = other return None def to_root_units(self): """Return Quantity rescaled to base units """ _, other = self._REGISTRY._get_root_units(self._units) magnitude = self._convert_magnitude_not_inplace(other) return self.__class__(magnitude, other) def ito_base_units(self): """Return Quantity rescaled to base units """ _, other = self._REGISTRY._get_base_units(self._units) self._magnitude = self._convert_magnitude(other) self._units = other return None def to_base_units(self): """Return Quantity rescaled to base units """ _, other = self._REGISTRY._get_base_units(self._units) magnitude = self._convert_magnitude_not_inplace(other) return self.__class__(magnitude, other) def ito_reduced_units(self): """Return Quantity scaled in place to reduced units, i.e. one unit per dimension. This will not reduce compound units (intentionally), nor can it make use of contexts at this time. """ #shortcuts in case we're dimensionless or only a single unit if self.dimensionless: return self.ito({}) if len(self._units) == 1: return None newunits = self._units.copy() #loop through individual units and compare to each other unit #can we do better than a nested loop here? for unit1, exp in self._units.items(): for unit2 in newunits: if unit1 != unit2: power = self._REGISTRY._get_dimensionality_ratio(unit1, unit2) if power: newunits = newunits.add(unit2, exp/power).remove(unit1) break return self.ito(newunits) def to_reduced_units(self): """Return Quantity scaled in place to reduced units, i.e. one unit per dimension. This will not reduce compound units (intentionally), nor can it make use of contexts at this time. """ #can we make this more efficient? newq = copy.copy(self) newq.ito_reduced_units() return newq def to_compact(self, unit=None): """Return Quantity rescaled to compact, human-readable units. To get output in terms of a different unit, use the unit parameter. >>> import pint >>> ureg = pint.UnitRegistry() >>> (200e-9*ureg.s).to_compact() >>> (1e-2*ureg('kg m/s^2')).to_compact('N') """ if not isinstance(self.magnitude, numbers.Number): msg = ("to_compact applied to non numerical types " "has an undefined behavior.") w = RuntimeWarning(msg) warnings.warn(w, stacklevel=2) return self if (self.unitless or self.magnitude==0 or math.isnan(self.magnitude) or math.isinf(self.magnitude)): return self SI_prefixes = {} for prefix in self._REGISTRY._prefixes.values(): try: scale = prefix.converter.scale # Kludgy way to check if this is an SI prefix log10_scale = int(math.log10(scale)) if log10_scale == math.log10(scale): SI_prefixes[log10_scale] = prefix.name except: SI_prefixes[0] = '' SI_prefixes = sorted(SI_prefixes.items()) SI_powers = [item[0] for item in SI_prefixes] SI_bases = [item[1] for item in SI_prefixes] if unit is None: unit = infer_base_unit(self) q_base = self.to(unit) magnitude = q_base.magnitude units = list(q_base._units.items()) units_numerator = list(filter(lambda a: a[1]>0, units)) if len(units_numerator) > 0: unit_str, unit_power = units_numerator[0] else: unit_str, unit_power = units[0] if unit_power > 0: power = int(math.floor(math.log10(abs(magnitude)) / unit_power / 3)) * 3 else: power = int(math.ceil(math.log10(abs(magnitude)) / unit_power / 3)) * 3 prefix = SI_bases[bisect.bisect_left(SI_powers, power)] new_unit_str = prefix+unit_str new_unit_container = q_base._units.rename(unit_str, new_unit_str) return self.to(new_unit_container) # Mathematical operations def __int__(self): if self.dimensionless: return int(self._convert_magnitude_not_inplace(UnitsContainer())) raise DimensionalityError(self._units, 'dimensionless') def __long__(self): if self.dimensionless: return long_type(self._convert_magnitude_not_inplace(UnitsContainer())) raise DimensionalityError(self._units, 'dimensionless') def __float__(self): if self.dimensionless: return float(self._convert_magnitude_not_inplace(UnitsContainer())) raise DimensionalityError(self._units, 'dimensionless') def __complex__(self): if self.dimensionless: return complex(self._convert_magnitude_not_inplace(UnitsContainer())) raise DimensionalityError(self._units, 'dimensionless') def _iadd_sub(self, other, op): """Perform addition or subtraction operation in-place and return the result. :param other: object to be added to / subtracted from self :type other: Quantity or any type accepted by :func:`_to_magnitude` :param op: operator function (e.g. operator.add, operator.isub) :type op: function """ if not self._check(other): # other not from same Registry or not a Quantity try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented if _eq(other, 0, True): # If the other value is 0 (but not Quantity 0) # do the operation without checking units. # We do the calculation instead of just returning the same # value to enforce any shape checking and type casting due to # the operation. self._magnitude = op(self._magnitude, other_magnitude) elif self.dimensionless: self.ito(UnitsContainer()) self._magnitude = op(self._magnitude, other_magnitude) else: raise DimensionalityError(self._units, 'dimensionless') return self if not self.dimensionality == other.dimensionality: raise DimensionalityError(self._units, other._units, self.dimensionality, other.dimensionality) # Next we define some variables to make if-clauses more readable. self_non_mul_units = self._get_non_multiplicative_units() is_self_multiplicative = len(self_non_mul_units) == 0 if len(self_non_mul_units) == 1: self_non_mul_unit = self_non_mul_units[0] other_non_mul_units = other._get_non_multiplicative_units() is_other_multiplicative = len(other_non_mul_units) == 0 if len(other_non_mul_units) == 1: other_non_mul_unit = other_non_mul_units[0] # Presence of non-multiplicative units gives rise to several cases. if is_self_multiplicative and is_other_multiplicative: if self._units == other._units: self._magnitude = op(self._magnitude, other._magnitude) # If only self has a delta unit, other determines unit of result. elif self._get_delta_units() and not other._get_delta_units(): self._magnitude = op(self._convert_magnitude(other._units), other._magnitude) self._units = other._units else: self._magnitude = op(self._magnitude, other.to(self._units)._magnitude) elif (op == operator.isub and len(self_non_mul_units) == 1 and self._units[self_non_mul_unit] == 1 and not other._has_compatible_delta(self_non_mul_unit)): if self._units == other._units: self._magnitude = op(self._magnitude, other._magnitude) else: self._magnitude = op(self._magnitude, other.to(self._units)._magnitude) self._units = self._units.rename(self_non_mul_unit, 'delta_' + self_non_mul_unit) elif (op == operator.isub and len(other_non_mul_units) == 1 and other._units[other_non_mul_unit] == 1 and not self._has_compatible_delta(other_non_mul_unit)): # we convert to self directly since it is multiplicative self._magnitude = op(self._magnitude, other.to(self._units)._magnitude) elif (len(self_non_mul_units) == 1 # order of the dimension of offset unit == 1 ? and self._units[self_non_mul_unit] == 1 and other._has_compatible_delta(self_non_mul_unit)): # Replace offset unit in self by the corresponding delta unit. # This is done to prevent a shift by offset in the to()-call. tu = self._units.rename(self_non_mul_unit, 'delta_' + self_non_mul_unit) self._magnitude = op(self._magnitude, other.to(tu)._magnitude) elif (len(other_non_mul_units) == 1 # order of the dimension of offset unit == 1 ? and other._units[other_non_mul_unit] == 1 and self._has_compatible_delta(other_non_mul_unit)): # Replace offset unit in other by the corresponding delta unit. # This is done to prevent a shift by offset in the to()-call. tu = other._units.rename(other_non_mul_unit, 'delta_' + other_non_mul_unit) self._magnitude = op(self._convert_magnitude(tu), other._magnitude) self._units = other._units else: raise OffsetUnitCalculusError(self._units, other._units) return self @check_implemented def _add_sub(self, other, op): """Perform addition or subtraction operation and return the result. :param other: object to be added to / subtracted from self :type other: Quantity or any type accepted by :func:`_to_magnitude` :param op: operator function (e.g. operator.add, operator.isub) :type op: function """ if not self._check(other): # other not from same Registry or not a Quantity if _eq(other, 0, True): # If the other value is 0 (but not Quantity 0) # do the operation without checking units. # We do the calculation instead of just returning the same # value to enforce any shape checking and type casting due to # the operation. units = self._units magnitude = op(self._magnitude, _to_magnitude(other, self.force_ndarray)) elif self.dimensionless: units = UnitsContainer() magnitude = op(self.to(units)._magnitude, _to_magnitude(other, self.force_ndarray)) else: raise DimensionalityError(self._units, 'dimensionless') return self.__class__(magnitude, units) if not self.dimensionality == other.dimensionality: raise DimensionalityError(self._units, other._units, self.dimensionality, other.dimensionality) # Next we define some variables to make if-clauses more readable. self_non_mul_units = self._get_non_multiplicative_units() is_self_multiplicative = len(self_non_mul_units) == 0 if len(self_non_mul_units) == 1: self_non_mul_unit = self_non_mul_units[0] other_non_mul_units = other._get_non_multiplicative_units() is_other_multiplicative = len(other_non_mul_units) == 0 if len(other_non_mul_units) == 1: other_non_mul_unit = other_non_mul_units[0] # Presence of non-multiplicative units gives rise to several cases. if is_self_multiplicative and is_other_multiplicative: if self._units == other._units: magnitude = op(self._magnitude, other._magnitude) units = self._units # If only self has a delta unit, other determines unit of result. elif self._get_delta_units() and not other._get_delta_units(): magnitude = op(self._convert_magnitude(other._units), other._magnitude) units = other._units else: units = self._units magnitude = op(self._magnitude, other.to(self._units).magnitude) elif (op == operator.sub and len(self_non_mul_units) == 1 and self._units[self_non_mul_unit] == 1 and not other._has_compatible_delta(self_non_mul_unit)): if self._units == other._units: magnitude = op(self._magnitude, other._magnitude) else: magnitude = op(self._magnitude, other.to(self._units)._magnitude) units = self._units.rename(self_non_mul_unit, 'delta_' + self_non_mul_unit) elif (op == operator.sub and len(other_non_mul_units) == 1 and other._units[other_non_mul_unit] == 1 and not self._has_compatible_delta(other_non_mul_unit)): # we convert to self directly since it is multiplicative magnitude = op(self._magnitude, other.to(self._units)._magnitude) units = self._units elif (len(self_non_mul_units) == 1 # order of the dimension of offset unit == 1 ? and self._units[self_non_mul_unit] == 1 and other._has_compatible_delta(self_non_mul_unit)): # Replace offset unit in self by the corresponding delta unit. # This is done to prevent a shift by offset in the to()-call. tu = self._units.rename(self_non_mul_unit, 'delta_' + self_non_mul_unit) magnitude = op(self._magnitude, other.to(tu).magnitude) units = self._units elif (len(other_non_mul_units) == 1 # order of the dimension of offset unit == 1 ? and other._units[other_non_mul_unit] == 1 and self._has_compatible_delta(other_non_mul_unit)): # Replace offset unit in other by the corresponding delta unit. # This is done to prevent a shift by offset in the to()-call. tu = other._units.rename(other_non_mul_unit, 'delta_' + other_non_mul_unit) magnitude = op(self._convert_magnitude(tu), other._magnitude) units = other._units else: raise OffsetUnitCalculusError(self._units, other._units) return self.__class__(magnitude, units) def __iadd__(self, other): if isinstance(other, datetime.datetime): return self.to_timedelta() + other elif not isinstance(self._magnitude, ndarray): return self._add_sub(other, operator.add) else: return self._iadd_sub(other, operator.iadd) def __add__(self, other): if isinstance(other, datetime.datetime): return self.to_timedelta() + other else: return self._add_sub(other, operator.add) __radd__ = __add__ def __isub__(self, other): if not isinstance(self._magnitude, ndarray): return self._add_sub(other, operator.sub) else: return self._iadd_sub(other, operator.isub) def __sub__(self, other): return self._add_sub(other, operator.sub) def __rsub__(self, other): if isinstance(other, datetime.datetime): return other - self.to_timedelta() else: return -self._add_sub(other, operator.sub) @ireduce_dimensions def _imul_div(self, other, magnitude_op, units_op=None): """Perform multiplication or division operation in-place and return the result. :param other: object to be multiplied/divided with self :type other: Quantity or any type accepted by :func:`_to_magnitude` :param magnitude_op: operator function to perform on the magnitudes (e.g. operator.mul) :type magnitude_op: function :param units_op: operator function to perform on the units; if None, *magnitude_op* is used :type units_op: function or None """ if units_op is None: units_op = magnitude_op offset_units_self = self._get_non_multiplicative_units() no_offset_units_self = len(offset_units_self) if not self._check(other): if not self._ok_for_muldiv(no_offset_units_self): raise OffsetUnitCalculusError(self._units, getattr(other, 'units', '')) if len(offset_units_self) == 1: if (self._units[offset_units_self[0]] != 1 or magnitude_op not in [operator.mul, operator.imul]): raise OffsetUnitCalculusError(self._units, getattr(other, 'units', '')) try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented self._magnitude = magnitude_op(self._magnitude, other_magnitude) self._units = units_op(self._units, UnitsContainer()) return self if isinstance(other, self._REGISTRY.Unit): other = 1.0 * other if not self._ok_for_muldiv(no_offset_units_self): raise OffsetUnitCalculusError(self._units, other._units) elif no_offset_units_self == 1 and len(self._units) == 1: self.ito_root_units() no_offset_units_other = len(other._get_non_multiplicative_units()) if not other._ok_for_muldiv(no_offset_units_other): raise OffsetUnitCalculusError(self._units, other._units) elif no_offset_units_other == 1 and len(other._units) == 1: other.ito_root_units() self._magnitude = magnitude_op(self._magnitude, other._magnitude) self._units = units_op(self._units, other._units) return self @check_implemented @ireduce_dimensions def _mul_div(self, other, magnitude_op, units_op=None): """Perform multiplication or division operation and return the result. :param other: object to be multiplied/divided with self :type other: Quantity or any type accepted by :func:`_to_magnitude` :param magnitude_op: operator function to perform on the magnitudes (e.g. operator.mul) :type magnitude_op: function :param units_op: operator function to perform on the units; if None, *magnitude_op* is used :type units_op: function or None """ if units_op is None: units_op = magnitude_op offset_units_self = self._get_non_multiplicative_units() no_offset_units_self = len(offset_units_self) if not self._check(other): if not self._ok_for_muldiv(no_offset_units_self): raise OffsetUnitCalculusError(self._units, getattr(other, 'units', '')) if len(offset_units_self) == 1: if (self._units[offset_units_self[0]] != 1 or magnitude_op not in [operator.mul, operator.imul]): raise OffsetUnitCalculusError(self._units, getattr(other, 'units', '')) try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented magnitude = magnitude_op(self._magnitude, other_magnitude) units = units_op(self._units, UnitsContainer()) return self.__class__(magnitude, units) if isinstance(other, self._REGISTRY.Unit): other = 1.0 * other new_self = self if not self._ok_for_muldiv(no_offset_units_self): raise OffsetUnitCalculusError(self._units, other._units) elif no_offset_units_self == 1 and len(self._units) == 1: new_self = self.to_root_units() no_offset_units_other = len(other._get_non_multiplicative_units()) if not other._ok_for_muldiv(no_offset_units_other): raise OffsetUnitCalculusError(self._units, other._units) elif no_offset_units_other == 1 and len(other._units) == 1: other = other.to_root_units() magnitude = magnitude_op(new_self._magnitude, other._magnitude) units = units_op(new_self._units, other._units) return self.__class__(magnitude, units) def __imul__(self, other): if not isinstance(self._magnitude, ndarray): return self._mul_div(other, operator.mul) else: return self._imul_div(other, operator.imul) def __mul__(self, other): return self._mul_div(other, operator.mul) __rmul__ = __mul__ def __itruediv__(self, other): if not isinstance(self._magnitude, ndarray): return self._mul_div(other, operator.truediv) else: return self._imul_div(other, operator.itruediv) def __truediv__(self, other): return self._mul_div(other, operator.truediv) def __rtruediv__(self, other): try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented no_offset_units_self = len(self._get_non_multiplicative_units()) if not self._ok_for_muldiv(no_offset_units_self): raise OffsetUnitCalculusError(self._units, '') elif no_offset_units_self == 1 and len(self._units) == 1: self = self.to_root_units() return self.__class__(other_magnitude / self._magnitude, 1 / self._units) __div__ = __truediv__ __rdiv__ = __rtruediv__ __idiv__ = __itruediv__ def __ifloordiv__(self, other): if self._check(other): self._magnitude //= other.to(self._units)._magnitude elif self.dimensionless: self._magnitude = self.to('')._magnitude // other else: raise DimensionalityError(self._units, 'dimensionless') self._units = UnitsContainer({}) return self @check_implemented def __floordiv__(self, other): if self._check(other): magnitude = self._magnitude // other.to(self._units)._magnitude elif self.dimensionless: magnitude = self.to('')._magnitude // other else: raise DimensionalityError(self._units, 'dimensionless') return self.__class__(magnitude, UnitsContainer({})) @check_implemented def __rfloordiv__(self, other): if self._check(other): magnitude = other._magnitude // self.to(other._units)._magnitude elif self.dimensionless: magnitude = other // self.to('')._magnitude else: raise DimensionalityError(self._units, 'dimensionless') return self.__class__(magnitude, UnitsContainer({})) def __imod__(self, other): if not self._check(other): other = self.__class__(other, UnitsContainer({})) self._magnitude %= other.to(self._units)._magnitude return self @check_implemented def __mod__(self, other): if not self._check(other): other = self.__class__(other, UnitsContainer({})) magnitude = self._magnitude % other.to(self._units)._magnitude return self.__class__(magnitude, self._units) @check_implemented def __rmod__(self, other): if self._check(other): magnitude = other._magnitude % self.to(other._units)._magnitude return self.__class__(magnitude, other._units) elif self.dimensionless: magnitude = other % self.to('')._magnitude return self.__class__(magnitude, UnitsContainer({})) else: raise DimensionalityError(self._units, 'dimensionless') @check_implemented def __divmod__(self, other): if not self._check(other): other = self.__class__(other, UnitsContainer({})) q, r = divmod(self._magnitude, other.to(self._units)._magnitude) return (self.__class__(q, UnitsContainer({})), self.__class__(r, self._units)) @check_implemented def __rdivmod__(self, other): if self._check(other): q, r = divmod(other._magnitude, self.to(other._units)._magnitude) unit = other._units elif self.dimensionless: q, r = divmod(other, self.to('')._magnitude) unit = UnitsContainer({}) else: raise DimensionalityError(self._units, 'dimensionless') return (self.__class__(q, UnitsContainer({})), self.__class__(r, unit)) def __ipow__(self, other): if not isinstance(self._magnitude, ndarray): return self.__pow__(other) try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented else: if not self._ok_for_muldiv: raise OffsetUnitCalculusError(self._units) if isinstance(getattr(other, '_magnitude', other), ndarray): # arrays are refused as exponent, because they would create # len(array) quantities of len(set(array)) different units # unless the base is dimensionless. if self.dimensionless: if getattr(other, 'dimensionless', False): self._magnitude **= other.m_as('') return self elif not getattr(other, 'dimensionless', True): raise DimensionalityError(other._units, 'dimensionless') else: self._magnitude **= other return self elif np.size(other) > 1: raise DimensionalityError(self._units, 'dimensionless', extra_msg='Quantity array exponents are only allowed ' 'if the base is dimensionless') if other == 1: return self elif other == 0: self._units = UnitsContainer() else: if not self._is_multiplicative: if self._REGISTRY.autoconvert_offset_to_baseunit: self.ito_base_units() else: raise OffsetUnitCalculusError(self._units) if getattr(other, 'dimensionless', False): other = other.to_base_units().magnitude self._units **= other elif not getattr(other, 'dimensionless', True): raise DimensionalityError(self._units, 'dimensionless') else: self._units **= other self._magnitude **= _to_magnitude(other, self.force_ndarray) return self @check_implemented def __pow__(self, other): try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented else: if not self._ok_for_muldiv: raise OffsetUnitCalculusError(self._units) if isinstance(getattr(other, '_magnitude', other), ndarray): # arrays are refused as exponent, because they would create # len(array) quantities of len(set(array)) different units # unless the base is dimensionless. if self.dimensionless: if getattr(other, 'dimensionless', False): return self.__class__(self.m ** other.m_as('')) elif not getattr(other, 'dimensionless', True): raise DimensionalityError(other._units, 'dimensionless') else: return self.__class__(self.m ** other) elif np.size(other) > 1: raise DimensionalityError(self._units, 'dimensionless', extra_msg='Quantity array exponents are only allowed ' 'if the base is dimensionless') new_self = self if other == 1: return self elif other == 0: units = UnitsContainer() else: if not self._is_multiplicative: if self._REGISTRY.autoconvert_offset_to_baseunit: new_self = self.to_root_units() else: raise OffsetUnitCalculusError(self._units) if getattr(other, 'dimensionless', False): units = new_self._units ** other.to_root_units().magnitude elif not getattr(other, 'dimensionless', True): raise DimensionalityError(other._units, 'dimensionless') else: units = new_self._units ** other magnitude = new_self._magnitude ** _to_magnitude(other, self.force_ndarray) return self.__class__(magnitude, units) @check_implemented def __rpow__(self, other): try: other_magnitude = _to_magnitude(other, self.force_ndarray) except TypeError: return NotImplemented else: if not self.dimensionless: raise DimensionalityError(self._units, 'dimensionless') if isinstance(self._magnitude, ndarray): if np.size(self._magnitude) > 1: raise DimensionalityError(self._units, 'dimensionless') new_self = self.to_root_units() return other**new_self._magnitude def __abs__(self): return self.__class__(abs(self._magnitude), self._units) def __round__(self, ndigits=0): return self.__class__(round(self._magnitude, ndigits=ndigits), self._units) def __pos__(self): return self.__class__(operator.pos(self._magnitude), self._units) def __neg__(self): return self.__class__(operator.neg(self._magnitude), self._units) @check_implemented def __eq__(self, other): # We compare to the base class of Quantity because # each Quantity class is unique. if not isinstance(other, _Quantity): if _eq(other, 0, True): # Handle the special case in which we compare to zero # (or an array of zeros) if self._is_multiplicative: # compare magnitude return _eq(self._magnitude, other, False) else: # compare the magnitude after converting the # non-multiplicative quantity to base units if self._REGISTRY.autoconvert_offset_to_baseunit: return _eq(self.to_base_units()._magnitude, other, False) else: raise OffsetUnitCalculusError(self._units) return (self.dimensionless and _eq(self._convert_magnitude(UnitsContainer()), other, False)) if _eq(self._magnitude, 0, True) and _eq(other._magnitude, 0, True): return self.dimensionality == other.dimensionality if self._units == other._units: return _eq(self._magnitude, other._magnitude, False) try: return _eq(self._convert_magnitude_not_inplace(other._units), other._magnitude, False) except DimensionalityError: return False def __ne__(self, other): out = self.__eq__(other) if isinstance(out, ndarray): return np.logical_not(out) return not out @check_implemented def compare(self, other, op): if not isinstance(other, self.__class__): if self.dimensionless: return op(self._convert_magnitude_not_inplace(UnitsContainer()), other) elif _eq(other, 0, True): # Handle the special case in which we compare to zero # (or an array of zeros) if self._is_multiplicative: # compare magnitude return op(self._magnitude, other) else: # compare the magnitude after converting the # non-multiplicative quantity to base units if self._REGISTRY.autoconvert_offset_to_baseunit: return op(self.to_base_units()._magnitude, other) else: raise OffsetUnitCalculusError(self._units) else: raise ValueError('Cannot compare Quantity and {}'.format(type(other))) if self._units == other._units: return op(self._magnitude, other._magnitude) if self.dimensionality != other.dimensionality: raise DimensionalityError(self._units, other._units, self.dimensionality, other.dimensionality) return op(self.to_root_units().magnitude, other.to_root_units().magnitude) __lt__ = lambda self, other: self.compare(other, op=operator.lt) __le__ = lambda self, other: self.compare(other, op=operator.le) __ge__ = lambda self, other: self.compare(other, op=operator.ge) __gt__ = lambda self, other: self.compare(other, op=operator.gt) def __bool__(self): return bool(self._magnitude) __nonzero__ = __bool__ # NumPy Support __radian = 'radian' __same_units = 'equal greater greater_equal less less_equal not_equal arctan2'.split() #: Dictionary mapping ufunc/attributes names to the units that they #: require (conversion will be tried). __require_units = {'cumprod': '', 'arccos': '', 'arcsin': '', 'arctan': '', 'arccosh': '', 'arcsinh': '', 'arctanh': '', 'exp': '', 'expm1': '', 'exp2': '', 'log': '', 'log10': '', 'log1p': '', 'log2': '', 'sin': __radian, 'cos': __radian, 'tan': __radian, 'sinh': __radian, 'cosh': __radian, 'tanh': __radian, 'radians': 'degree', 'degrees': __radian, 'deg2rad': 'degree', 'rad2deg': __radian, 'logaddexp': '', 'logaddexp2': ''} #: Dictionary mapping ufunc/attributes names to the units that they #: will set on output. __set_units = {'cos': '', 'sin': '', 'tan': '', 'cosh': '', 'sinh': '', 'tanh': '', 'log': '', 'exp': '', 'arccos': __radian, 'arcsin': __radian, 'arctan': __radian, 'arctan2': __radian, 'arccosh': __radian, 'arcsinh': __radian, 'arctanh': __radian, 'degrees': 'degree', 'radians': __radian, 'expm1': '', 'cumprod': '', 'rad2deg': 'degree', 'deg2rad': __radian} #: List of ufunc/attributes names in which units are copied from the #: original. __copy_units = 'compress conj conjugate copy cumsum diagonal flatten ' \ 'max mean min ptp ravel repeat reshape round ' \ 'squeeze std sum swapaxes take trace transpose ' \ 'ceil floor hypot rint ' \ 'add subtract ' \ 'copysign nextafter trunc ' \ 'frexp ldexp modf modf__1 ' \ 'absolute negative remainder fmod mod'.split() #: Dictionary mapping ufunc/attributes names to the units that they will #: set on output. The value is interpreted as the power to which the unit #: will be raised. __prod_units = {'var': 2, 'prod': 'size', 'multiply': 'mul', 'true_divide': 'div', 'divide': 'div', 'floor_divide': 'div', 'remainder': 'div', 'sqrt': .5, 'square': 2, 'reciprocal': -1} __skip_other_args = 'ldexp multiply ' \ 'true_divide divide floor_divide fmod mod ' \ 'remainder'.split() __handled = tuple(__same_units) + \ tuple(__require_units.keys()) + \ tuple(__prod_units.keys()) + \ tuple(__copy_units) + tuple(__skip_other_args) def clip(self, first=None, second=None, out=None, **kwargs): min = kwargs.get('min', first) max = kwargs.get('max', second) if min is None and max is None: raise TypeError('clip() takes at least 3 arguments (2 given)') if max is None and 'min' not in kwargs: min, max = max, min kwargs = {'out': out} if min is not None: if isinstance(min, self.__class__): kwargs['min'] = min.to(self).magnitude elif self.dimensionless: kwargs['min'] = min else: raise DimensionalityError('dimensionless', self._units) if max is not None: if isinstance(max, self.__class__): kwargs['max'] = max.to(self).magnitude elif self.dimensionless: kwargs['max'] = max else: raise DimensionalityError('dimensionless', self._units) return self.__class__(self.magnitude.clip(**kwargs), self._units) def fill(self, value): self._units = value._units return self.magnitude.fill(value.magnitude) def put(self, indices, values, mode='raise'): if isinstance(values, self.__class__): values = values.to(self).magnitude elif self.dimensionless: values = self.__class__(values, '').to(self) else: raise DimensionalityError('dimensionless', self._units) self.magnitude.put(indices, values, mode) @property def real(self): return self.__class__(self._magnitude.real, self._units) @property def imag(self): return self.__class__(self._magnitude.imag, self._units) @property def T(self): return self.__class__(self._magnitude.T, self._units) @property def flat(self): for v in self._magnitude.flat: yield self.__class__(v, self._units) @property def shape(self): return self._magnitude.shape @shape.setter def shape(self, value): self._magnitude.shape = value def searchsorted(self, v, side='left', sorter=None): if isinstance(v, self.__class__): v = v.to(self).magnitude elif self.dimensionless: v = self.__class__(v, '').to(self) else: raise DimensionalityError('dimensionless', self._units) return self.magnitude.searchsorted(v, side) def __ito_if_needed(self, to_units): if self.unitless and to_units == 'radian': return self.ito(to_units) def __numpy_method_wrap(self, func, *args, **kwargs): """Convenience method to wrap on the fly numpy method taking care of the units. """ if func.__name__ in self.__require_units: self.__ito_if_needed(self.__require_units[func.__name__]) value = func(*args, **kwargs) if func.__name__ in self.__copy_units: return self.__class__(value, self._units) if func.__name__ in self.__prod_units: tmp = self.__prod_units[func.__name__] if tmp == 'size': return self.__class__(value, self._units ** self._magnitude.size) return self.__class__(value, self._units ** tmp) return value def __len__(self): return len(self._magnitude) def __getattr__(self, item): # Attributes starting with `__array_` are common attributes of NumPy ndarray. # They are requested by numpy functions. if item.startswith('__array_'): warnings.warn("The unit of the quantity is stripped.", UnitStrippedWarning) if isinstance(self._magnitude, ndarray): return getattr(self._magnitude, item) else: # If an `__array_` attributes is requested but the magnitude is not an ndarray, # we convert the magnitude to a numpy ndarray. self._magnitude = _to_magnitude(self._magnitude, force_ndarray=True) return getattr(self._magnitude, item) elif item in self.__handled: if not isinstance(self._magnitude, ndarray): self._magnitude = _to_magnitude(self._magnitude, True) attr = getattr(self._magnitude, item) if callable(attr): return functools.partial(self.__numpy_method_wrap, attr) return attr try: return getattr(self._magnitude, item) except AttributeError as ex: raise AttributeError("Neither Quantity object nor its magnitude ({}) " "has attribute '{}'".format(self._magnitude, item)) def __getitem__(self, key): try: value = self._magnitude[key] return self.__class__(value, self._units) except TypeError: raise TypeError("Neither Quantity object nor its magnitude ({})" "supports indexing".format(self._magnitude)) def __setitem__(self, key, value): try: if math.isnan(value): self._magnitude[key] = value return except (TypeError, DimensionalityError): pass try: if isinstance(value, self.__class__): factor = self.__class__(value.magnitude, value._units / self._units).to_root_units() else: factor = self.__class__(value, self._units ** (-1)).to_root_units() if isinstance(factor, self.__class__): if not factor.dimensionless: raise DimensionalityError(value, self.units, extra_msg='. Assign a quantity with the same dimensionality or ' 'access the magnitude directly as ' '`obj.magnitude[%s] = %s`' % (key, value)) self._magnitude[key] = factor.magnitude else: self._magnitude[key] = factor except TypeError: raise TypeError("Neither Quantity object nor its magnitude ({})" "supports indexing".format(self._magnitude)) def tolist(self): units = self._units return [self.__class__(value, units).tolist() if isinstance(value, list) else self.__class__(value, units) for value in self._magnitude.tolist()] __array_priority__ = 17 def _call_ufunc(self, ufunc, *inputs, **kwargs): # Store the destination units dst_units = None # List of magnitudes of Quantities with the right units # to be used as argument of the ufunc mobjs = None if ufunc.__name__ in self.__require_units: # ufuncs in __require_units # require specific units # This is more complex that it should be due to automatic # conversion between radians/dimensionless # TODO: maybe could be simplified using Contexts dst_units = self.__require_units[ufunc.__name__] if dst_units == 'radian': mobjs = [] for other in inputs: unt = getattr(other, '_units', '') if unt == 'radian': mobjs.append(getattr(other, 'magnitude', other)) else: factor, units = self._REGISTRY._get_root_units(unt) if units and units != UnitsContainer({'radian': 1}): raise DimensionalityError(units, dst_units) mobjs.append(getattr(other, 'magnitude', other) * factor) mobjs = tuple(mobjs) else: dst_units = self._REGISTRY.parse_expression(dst_units)._units elif len(inputs) > 1 and ufunc.__name__ not in self.__skip_other_args: # ufunc with multiple arguments require that all inputs have # the same arguments unless they are in __skip_other_args dst_units = getattr(inputs[0], "_units", None) # Do the conversion (if needed) and extract the magnitude for each input. if mobjs is None: if dst_units is not None: mobjs = tuple(self._REGISTRY.convert(getattr(other, 'magnitude', other), getattr(other, 'units', ''), dst_units) for other in inputs) else: mobjs = tuple(getattr(other, 'magnitude', other) for other in inputs) # call the ufunc try: return ufunc(*mobjs) except Exception as ex: raise _Exception(ex) def _wrap_output(self, ufname, i, objs, out): """we set the units of the output value""" if i > 0: ufname = "{}__{}".format(ufname, i) if ufname in self.__set_units: try: out = self.__class__(out, self.__set_units[ufname]) except: raise _Exception(ValueError) elif ufname in self.__copy_units: try: out = self.__class__(out, self._units) except: raise _Exception(ValueError) elif ufname in self.__prod_units: tmp = self.__prod_units[ufname] if tmp == 'size': out = self.__class__(out, self._units ** self._magnitude.size) elif tmp == 'div': units1 = objs[0]._units if isinstance(objs[0], self.__class__) else UnitsContainer() units2 = objs[1]._units if isinstance(objs[1], self.__class__) else UnitsContainer() out = self.__class__(out, units1 / units2) elif tmp == 'mul': units1 = objs[0]._units if isinstance(objs[0], self.__class__) else UnitsContainer() units2 = objs[1]._units if isinstance(objs[1], self.__class__) else UnitsContainer() out = self.__class__(out, units1 * units2) else: out = self.__class__(out, self._units ** tmp) return out def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): if method != "__call__": return NotImplemented try: out = self._call_ufunc(ufunc, *inputs, **kwargs) if isinstance(out, tuple): ret = tuple(self._wrap_output(ufunc.__name__, i, inputs, o) for i, o in enumerate(out)) return ret else: return self._wrap_output(ufunc.__name__, 0, inputs, out) except (DimensionalityError, UndefinedUnitError): raise except _Exception as ex: raise ex.internal except: return NotImplemented def __array_prepare__(self, obj, context=None): # If this uf is handled by Pint, write it down in the handling dictionary. # name of the ufunc, argument of the ufunc, domain of the ufunc # In ufuncs with multiple outputs, domain indicates which output # is currently being prepared (eg. see modf). # In ufuncs with a single output, domain is 0 uf, objs, i_out = context if uf.__name__ in self.__handled and i_out == 0: # Only one ufunc should be handled at a time. # If a ufunc is already being handled (and this is not another domain), # something is wrong.. if self.__handling: raise Exception('Cannot handled nested ufuncs.\n' 'Current: {}\n' 'New: {}'.format(context, self.__handling)) self.__handling = context return obj def __array_wrap__(self, obj, context=None): uf, objs, i_out = context # if this ufunc is not handled by Pint, pass it to the magnitude. if uf.__name__ not in self.__handled: return self.magnitude.__array_wrap__(obj, context) try: # First, we check the units of the input arguments. if i_out == 0: out = self._call_ufunc(uf, *objs) # If there are multiple outputs, # store them in __handling (uf, objs, i_out, out0, out1, ...) # and return the first if uf.nout > 1: self.__handling += out out = out[0] else: # If this is not the first output, # just grab the result that was previously calculated. out = self.__handling[3 + i_out] return self._wrap_output(uf.__name__, i_out, objs, out) except (DimensionalityError, UndefinedUnitError) as ex: raise ex except _Exception as ex: raise ex.internal except Exception as ex: print(ex) finally: # If this is the last output argument for the ufunc, # we are done handling this ufunc. if uf.nout == i_out + 1: self.__handling = None return self.magnitude.__array_wrap__(obj, context) # Measurement support def plus_minus(self, error, relative=False): if isinstance(error, self.__class__): if relative: raise ValueError('{} is not a valid relative error.'.format(error)) error = error.to(self._units).magnitude else: if relative: error = error * abs(self.magnitude) return self._REGISTRY.Measurement(copy.copy(self.magnitude), error, self._units) # methods/properties that help for math operations with offset units @property def _is_multiplicative(self): """Check if the Quantity object has only multiplicative units. """ return not self._get_non_multiplicative_units() def _get_non_multiplicative_units(self): """Return a list of the of non-multiplicative units of the Quantity object """ offset_units = [unit for unit in self._units.keys() if not self._REGISTRY._units[unit].is_multiplicative] return offset_units def _get_delta_units(self): """Return list of delta units ot the Quantity object """ delta_units = [u for u in self._units.keys() if u.startswith("delta_")] return delta_units def _has_compatible_delta(self, unit): """"Check if Quantity object has a delta_unit that is compatible with unit """ deltas = self._get_delta_units() if 'delta_' + unit in deltas: return True else: # Look for delta units with same dimension as the offset unit offset_unit_dim = self._REGISTRY._units[unit].reference for d in deltas: if self._REGISTRY._units[d].reference == offset_unit_dim: return True return False def _ok_for_muldiv(self, no_offset_units=None): """Checks if Quantity object can be multiplied or divided :q: quantity object that is checked :no_offset_units: number of offset units in q """ is_ok = True if no_offset_units is None: no_offset_units = len(self._get_non_multiplicative_units()) if no_offset_units > 1: is_ok = False if no_offset_units == 1: if len(self._units) > 1: is_ok = False if (len(self._units) == 1 and not self._REGISTRY.autoconvert_offset_to_baseunit): is_ok = False if next(iter(self._units.values())) != 1: is_ok = False return is_ok def to_timedelta(self): return datetime.timedelta(microseconds=self.to('microseconds').magnitude) def build_quantity_class(registry, force_ndarray=False): class Quantity(_Quantity): pass Quantity._REGISTRY = registry Quantity.force_ndarray = force_ndarray return Quantity