Source code for sympy.physics.unitsystems.units

# -*- coding: utf-8 -*-

"""
Unit system for physical quantities; include definition of constants.
"""

from __future__ import division
import numbers

from sympy import sympify, Expr, Number, Pow, Mul
from .dimensions import Dimension, DimensionSystem


[docs]class Unit(Expr): """ Class for the units. A unit is defined by two things: - a dimension; - a factor. The factor represents the position of the unit with respect to the canonical unit of this dimension. For example if we choose the gram to be the canonical dimension for the mass, then by definition its factor is 1; on the other hand the factor defined here for kilogram is 1000, even when it is a base unit. The explanation is that here we do not have defined any system that we could use as a reference: here the canonical unit is the only scale, and thus the only available origin. Additionnaly one can add a prefix and an abbreviation. The only utility of the former is to provide a shorthand for some units, but it is never used among computations; it appears only when defining and printing units. The same remark applies to the abbreviation. All operations (pow, mul, etc.) are defined as the corresponding ones acting on the factor (a number) and the dimension. """ is_commutative = True is_number = False def __new__(cls, dim, abbrev="", factor=1, prefix=None, **assumptions): """ Create a new unit instance. ``dim`` can be a Dimension or Unit object. The latter allows to construct derived units and constants. Note that the argument prefix is ignored if ``dim`` is a Unit instance and already has a prefix. """ factor = sympify(factor) obj_abbrev = abbrev obj_factor = factor obj_dim = dim obj_prefix = prefix if isinstance(dim, Unit): obj_factor = factor * dim.factor obj_dim = dim.dim #TODO: find a better handling when dim has already a prefix if dim.prefix is None and prefix is not None: obj_prefix = prefix else: obj_prefix = None else: if not isinstance(dim, Dimension): raise TypeError("'dim' object should be Unit or Dimension " "instance; found %s" % type(dim)) # compute the total factor - including the prefix - to pass to Expr if obj_prefix is not None: arg_factor = obj_prefix.factor * obj_factor else: arg_factor = obj_factor # we can not define obj at the beginning and define its attributes # in the previous conditions because one needs to compute the total # factor and pass it in args obj = Expr.__new__(cls, arg_factor, obj_dim, **assumptions) obj._abbrev = obj_abbrev obj._factor = obj_factor obj.dim = obj_dim obj.prefix = obj_prefix return obj @property
[docs] def factor(self): """ Overall magnitude of the unit. """ if self.prefix is not None: return self.prefix.factor * self._factor else: return self._factor
@property
[docs] def abbrev(self): """ Symbol representing the unit name. Prepend the abbreviation with the prefix symbol if it is defines. """ if self._abbrev == "": return "" if self.prefix is not None: return self.prefix.abbrev + self._abbrev else: return self._abbrev
@property
[docs] def abbrev_dim(self): """ Abbreviation which use only intrinsinc properties of the unit. """ return '(%g %s)' % (self.factor, self.dim)
def __str__(self): if self.abbrev != "": return self.abbrev else: return self.abbrev_dim def __repr__(self): return self.abbrev_dim def add(self, other): if not isinstance(other, Unit): raise TypeError("Only unit can be added; '%s' is not valid" % type(other)) else: if self.is_compatible(other): return Unit(self.dim, factor=self.factor + other.factor) else: raise ValueError("Only dimension which are equal can be " "added; '%s' and '%s' are different" % (self, other)) def sub(self, other): if not isinstance(other, Unit): raise TypeError("Only unit can be added; '%s' is not valid" % type(other)) else: if self.is_compatible(other): return Unit(self.dim, factor=self.factor - other.factor) else: raise ValueError("Only dimension which are equal can be " "subtracted; '%s' and '%s' are different" % (self, other)) def pow(self, other): other = sympify(other) #TODO: check consistency when having rational, float... if isinstance(other, (numbers.Real, Number)): if other == 0: return sympify(1) elif other == 1: return self else: factor = (self.factor**other).evalf() dim = self.dim.pow(other) if dim == 1: return factor else: return Unit(dim, factor=factor) else: return Pow(self, other) def mul(self, other): other = sympify(other) if other == 1: return self elif isinstance(other, Unit): factor = self.factor * other.factor dim = self.dim.mul(other.dim) if dim == 1: return factor else: return Unit(dim, factor=factor) #TODO: what to do when other is a number? return a unit or a quantity? # or nothing special? #elif isinstance(other, Number): # return Quantity(other, self) #elif other.is_number: # factor = self.factor * other # return Unit(self.dim, factor=factor) else: return Mul(self, other) def div(self, other): other = sympify(other) if other == 1: return self elif isinstance(other, Unit): factor = self.factor / other.factor dim = self.dim.div(other.dim) if dim == 1: return factor else: return Unit(dim, factor=factor) #TODO same remark as in __mul__ #elif isinstance(other, Number): # return Quantity(1/other, unit) #elif other.is_number: #factor = self.factor / other #return Unit(self.dimension, factor=factor, system=system) else: return Mul(self, Pow(other, -1)) def rdiv(self, other): return self.pow(-1).mul(other)
[docs] def is_compatible(self, other): """ Test if argument is a unit and has the same dimension as self. This function is used to verify that some operations can be done. """ if isinstance(other, Unit): if self.dim == other.dim: return True return False
@property
[docs] def as_quantity(self): """ Convert the unit to a quantity. The quantity unit is given by the unit of factor 1 and with identical dimension. >>> from sympy.physics.unitsystems.dimensions import Dimension >>> from sympy.physics.unitsystems.units import Unit >>> length = Dimension(length=1) >>> u = Unit(length, factor=10) >>> q = u.as_quantity >>> q.factor 10 >>> q.unit == Unit(length) True """ from .quantities import Quantity return Quantity(self.factor, Unit(self.dim))
[docs]class Constant(Unit): """ Physical constant. In our framework a constant is considered as a unit, to which humans givesa special sense, because we believe that they give us a special information on nature; but it is just a demonstration of our ignorance. """ #TODO: to begin nothing more is needed, but we prepare a dedicated class # for further developments pass
[docs]class UnitSystem(object): """ UnitSystem represents a coherent set of units. A unit system is basically a dimension system with notions of scales. Many of the methods are defined in the same way. It is much better if all base units have a symbol. """ def __init__(self, base, units=(), name="", descr=""): self.name = name self.descr = descr # construct the associated dimension system self._system = DimensionSystem([u.dim for u in base], [u.dim for u in units]) if self.is_consistent is False: raise ValueError("The system with basis '%s' is not consistent" % str(self._base_units)) self._units = tuple(set(base) | set(units)) # create a dict linkin # this is possible since we have already verified that the base units # form a coherent system base_dict = dict((u.dim, u) for u in base) # order the base units in the same order than the dimensions in the # associated system, in order to ensure that we get always the same self._base_units = tuple(base_dict[d] for d in self._system._base_dims) def __str__(self): """ Return the name of the system. If it does not exist, then it makes a list of symbols (or names) of the base dimensions. """ if self.name != "": return self.name else: return "(%s)" % ", ".join(str(d) for d in self._base_units) def __repr__(self): return '<UnitSystem: %s>' % repr(self._base_units) def __getitem__(self, key): """ Shortcut to the get_unit method, using key access. """ u = self.get_unit(key) #TODO: really want to raise an error? if u is None: raise KeyError(key) return u def __call__(self, other): """ Display the argument in the current system units (or dimensions). The argument can be a dimension (call print_dim_base of the system), a unit (call print_unit_base) or a quantity """ from sympy.physics.unitsystems import Quantity if isinstance(other, Dimension): return self._system(other) elif isinstance(other, Unit): return self.print_unit_base(other) elif isinstance(other, Quantity): return "%g %s" % (other.factor, self.print_unit_base(other.unit)) else: raise TypeError("System is callable only with unit, dimension " "or quantity.")
[docs] def get_unit(self, unit): """ Find a specific unit which is part of the system. unit can be a string or a dimension object. If no unit is found, then return None. """ #TODO: if the argument is a list, return a list of all matching dims found_unit = None #TODO: use copy instead of direct assignment for found_dim? if isinstance(unit, str): for u in self._units: #TODO: verify not only abbrev if unit in (u.abbrev,): found_unit = u break elif isinstance(unit, Unit): try: i = self._units.index(unit) found_unit = self._units[i] except ValueError: pass return found_unit
[docs] def extend(self, base, units=(), name="", description=""): """ Extend the current system into a new one. Take the base and normal units of the current system to merge them to the base and normal units given in argument. If not provided, name and description are overriden by empty strings. """ base = self._base_units + tuple(base) units = self._units + tuple(units) return UnitSystem(base, units, name, description)
[docs] def print_unit_base(self, unit): """ Give the string expression of a unit in term of the basis. Units are displayed by decreasing power. """ res = "" factor = unit.factor vec = self._system.dim_vector(unit.dim) for (u, p) in sorted(zip(self._base_units, vec), key=lambda x: x[1], reverse=True): factor /= u.factor**p if p == 0: continue elif p == 1: res += "%s " % str(u) else: res += "%s^%d " % (str(u), p) return "%g %s" % (factor, res.strip())
@property
[docs] def dim(self): """ Give the dimension of the system. That is return the number of units forming the basis. """ return self._system.dim
@property
[docs] def is_consistent(self): """ Check if the underlying dimension system is consistent. """ return self._system.is_consistent