def test_Dimension_definition(): assert dimsys_SI.get_dimensional_dependencies(length) == {"length": 1} assert length.name == Symbol("length") assert length.symbol == Symbol("L") halflength = sqrt(length) assert dimsys_SI.get_dimensional_dependencies(halflength) == {"length": S.Half}
def test_Dimension_add_sub(): assert length + length == length assert length - length == length assert -length == length raises(TypeError, lambda: length + foot) raises(TypeError, lambda: foot + length) raises(TypeError, lambda: length - foot) raises(TypeError, lambda: foot - length) # issue 14547 - only raise error for dimensional args; allow # others to pass x = Symbol('x') e = length + x assert e == x + length and e.is_Add and set(e.args) == {length, x} e = length + 1 assert e == 1 + length == 1 - length and e.is_Add and set(e.args) == {length, 1} assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force) == \ {'length': 1, 'mass': 1, 'time': -2} assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force - pressure * length**2) == \ {'length': 1, 'mass': 1, 'time': -2} raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + pressure))
def __new__(cls, name, parents, dct): """Build and register new variable.""" if '__registry__' not in dct: unit = dct.pop('unit', S.One) if unit == 1: unit = S.One definition = dct.pop('expr', None) dct.setdefault('name', name) dct.setdefault('assumptions', {'real': True}) dct.setdefault('latex_name', dct['name']) dct.setdefault('unit', unit) instance = super(VariableMeta, cls).__new__(cls, name, parents, dct) # Variable with definition expression. if definition is not None: definition = build_instance_expression(instance, definition) derived_unit = derive_unit(definition, name=name) if unit == S.One: unit = derived_unit # only if unit is None instance.expr, instance.unit = definition, unit dim_derived = dimsys_SI.get_dimensional_dependencies( Variable.get_dimensional_expr(derived_unit)) dim_unit = dimsys_SI.get_dimensional_dependencies( Variable.get_dimensional_expr(unit)) if dim_derived != dim_unit: raise ValueError( 'Invalid expression units {0} should be {1}'.format( instance.unit, unit)) expr = BaseVariable(instance, dct['name'], abbrev=dct['latex_name'], dimension=Dimension( SI.get_dimensional_expr(unit)), scale_factor=unit or S.One, **dct['assumptions']) instance[expr] = instance # Store definition as variable expression. if definition is not None: instance.__expressions__[expr] = definition # Store default variable only if it is defined. if 'default' in dct: instance.__defaults__[expr] = dct['default'] # Store unit for each variable: instance.__units__[expr] = unit return expr return super(VariableMeta, cls).__new__(cls, name, parents, dct)
def derive_base_dimension(dim): """Derive base dimension of dimension.""" return functools.reduce( operator.mul, (Dimension(d)**p for d, p in dimsys_SI.get_dimensional_dependencies(dim).items()), Dimension(1))
def check_expression_dim(expression, dim_dict): if 'E' in expression: expression = expression.replace('E', 'exp(1)') try: expr_dim = eval(expression, dim_dict) except NameError: # sometimes the expressions contain faulty symbols # in that case return different "dimension", investigate if the rewards of these expressions are very good return (9, 9, 9, 9, 9, 9, 9) try: dims = dimsys_SI.get_dimensional_dependencies(expr_dim) except TypeError: return (10, 10, 10, 10, 10, 10, 10) #process dims: [mass, lenght, time, temp, quantity, current, luminousintensity] OF_dims = [0, 0, 0, 0, 0, 0, 0] for key in dims: # note only length and time implemented currently if key == 'time': OF_dims[2] = dims[key] elif key == 'length': OF_dims[1] = dims[key] return tuple(OF_dims)
def _Quantity_constructor_postprocessor_Add(expr): """Construct postprocessor for the addition. It checks for dimension mismatches of the addends, thus preventing expressions like ``meter + second`` to be created. """ deset = { tuple( sorted( dimsys_SI.get_dimensional_dependencies( Dimension( SI.get_dimensional_expr(i) if not i.is_number else 1)). items())) for i in expr.args if i.free_symbols == set() # do not raise if there are symbols # (free symbols could contain the units corrections) } # If `deset` has more than one element, then some dimensions do not # match in the sum: if len(deset) > 1: raise ValueError("summation of quantities of incompatible dimensions") return expr
def derive_baseunit(expr, name=None): """Derive SI base unit from an expression, omitting scale factors.""" from essm.variables import Variable from essm.variables.utils import extract_variables from sympy.physics.units import Dimension from sympy.physics.units.systems.si import dimsys_SI Variable.check_unit(expr) # check for dimensional consistency variables = extract_variables(expr) for var1 in variables: q1 = Quantity('q_' + str(var1)) SI.set_quantity_dimension( q1, Dimension( SI.get_dimensional_expr(derive_baseunit( var1.definition.unit)))) SI.set_quantity_scale_factor(q1, var1.definition.unit) expr = expr.xreplace({var1: q1}) dim = Dimension(Variable.get_dimensional_expr(expr)) return functools.reduce( operator.mul, (SI_BASE_DIMENSIONS[Symbol(d)]**p for d, p in dimsys_SI.get_dimensional_dependencies(dim).items()), 1)
def test_Dimension_mul_div_exp(): assert 2*length == length*2 == length/2 == length assert 2/length == 1/length x = Symbol('x') m = x*length assert m == length*x and m.is_Mul and set(m.args) == {x, length} d = x/length assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length} d = length/x assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length} velo = length / time assert (length * length) == length ** 2 assert dimsys_SI.get_dimensional_dependencies(length * length) == {"length": 2} assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {"length": 2} assert dimsys_SI.get_dimensional_dependencies(length * time) == { "length": 1, "time": 1} assert dimsys_SI.get_dimensional_dependencies(velo) == { "length": 1, "time": -1} assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {"length": 2, "time": -2} assert dimsys_SI.get_dimensional_dependencies(length / length) == {} assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {} assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {"length": -1} assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {"length": -1.5, "time": 1.5} length_a = length**"a" assert dimsys_SI.get_dimensional_dependencies(length_a) == {"length": Symbol("a")} assert length != 1 assert length / length != 1 length_0 = length ** 0 assert dimsys_SI.get_dimensional_dependencies(length_0) == {} # issue 18738 a = Symbol('a') b = Symbol('b') c = sqrt(a**2 + b**2) c_dim = c.subs({a: length, b: length}) assert dimsys_SI.equivalent_dims(c_dim, length)
def base_dimensions(d): dependencies = dimsys_SI.get_dimensional_dependencies(d) return Mul.fromiter( Pow(Dimension(base), exp_) for base, exp_ in dependencies.items())
def test_Dimension_mul_div_exp(): assert 2*length == length*2 == length/2 == length assert 2/length == 1/length x = Symbol('x') m = x*length assert m == length*x and m.is_Mul and set(m.args) == {x, length} d = x/length assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length} d = length/x assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length} velo = length / time assert (length * length) == length ** 2 assert dimsys_SI.get_dimensional_dependencies(length * length) == {"length": 2} assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {"length": 2} assert dimsys_SI.get_dimensional_dependencies(length * time) == { "length": 1, "time": 1} assert dimsys_SI.get_dimensional_dependencies(velo) == { "length": 1, "time": -1} assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {"length": 2, "time": -2} assert dimsys_SI.get_dimensional_dependencies(length / length) == {} assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {} assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {"length": -1} assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {"length": -1.5, "time": 1.5} length_a = length**"a" assert dimsys_SI.get_dimensional_dependencies(length_a) == {"length": Symbol("a")} assert length != 1 assert length / length != 1 length_0 = length ** 0 assert dimsys_SI.get_dimensional_dependencies(length_0) == {}
def test_Dimension_functions(): raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(cos(length))) raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(acos(angle))) raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(atan2(length, time))) raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length))) raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(100, length))) raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length, 10))) assert dimsys_SI.get_dimensional_dependencies(pi) == {} assert dimsys_SI.get_dimensional_dependencies(cos(1)) == {} assert dimsys_SI.get_dimensional_dependencies(cos(angle)) == {} assert dimsys_SI.get_dimensional_dependencies(atan2(length, length)) == {} assert dimsys_SI.get_dimensional_dependencies( log(length / length, length / length)) == {} assert dimsys_SI.get_dimensional_dependencies(Abs(length)) == {length: 1} assert dimsys_SI.get_dimensional_dependencies(Abs(length / length)) == {} assert dimsys_SI.get_dimensional_dependencies(sqrt(-1)) == {}
def test_issue_22819(): from sympy.physics.units import tonne, gram, Da from sympy.physics.units.systems.si import dimsys_SI assert tonne.convert_to(gram) == 1000000 * gram assert dimsys_SI.get_dimensional_dependencies(area) == {length: 2} assert Da.scale_factor == 1.66053906660000e-24