def test_cgs_gauss_convert_constants():
assert (convert_to(speed_of_light, centimeter / second,
cgs_gauss) == 29979245800 * centimeter / second)
assert convert_to(coulomb_constant, 1, cgs_gauss) == 1
assert convert_to(
coulomb_constant, newton * meter**2 / coulomb**2,
cgs_gauss) == 22468879468420441 * meter**2 * newton / (25000000000 *
coulomb**2)
assert convert_to(
coulomb_constant, newton * meter**2 / coulomb**2,
SI) == 22468879468420441 * meter**2 * newton / (2500000 * coulomb**2)
assert (convert_to(coulomb_constant, dyne * centimeter**2 / statcoulomb**2,
cgs_gauss) == centimeter**2 * dyne / statcoulomb**2)
assert convert_to(coulomb_constant, 1, SI) == coulomb_constant
assert (NS(
convert_to(coulomb_constant, newton * meter**2 / coulomb**2,
SI)) == "8987551787.36818*meter**2*newton/coulomb**2")
assert convert_to(elementary_charge, statcoulomb, cgs_gauss)
assert convert_to(gravitational_constant, dyne * centimeter**2 / gram**2,
cgs_gauss)
assert (NS(convert_to(planck, erg * second,
cgs_gauss)) == "6.62607015e-27*erg*second")
def test_deprecated_quantity_methods():
step = Quantity("step")
with warns_deprecated_sympy():
step.set_dimension(length)
step.set_scale_factor(2*meter)
assert convert_to(step, centimeter) == 200*centimeter
assert convert_to(1000*step/second, kilometer/second) == 2*kilometer/second
def __init__(self, val, dim=None, sigma=None, epsilon=None, symbol=None,
is_const=False):
"""
Physical Quantity
:param val: значение
:param dim: размерность величины. Если указана, используется она. Если None, берётся размерность val.
:param sigma: относительная погрешность
:param epsilon: абсолютная погрешность
Стоит указывать только одну погрешность, другая посчитается сама.
:param symbol: можно особо указать sympy символ (зачем?)
:param is_const: позволяет сделать константу, у которой не будет погрешностей.
Иначе же за погрешность надо брать последнюю цифру (не реализовано).
"""
if isinstance(val, PQ):
raise Exception("Не пытайтесь передать PQ как val или sigma. Явно пропишите к нему .val")
self.dim = None
if dim is not None:
self.dim = dim
else:
if val != 0:
self.dim = PQ.get_dim(val)
elif sigma is not None:
self.dim = PQ.get_dim(sigma)
else:
raise Exception('Impossible to deduce dim (note: zero is dimensionless)')
self.val = u.convert_to(val, self.dim)
if sigma is not None:
self.sigma = u.convert_to(sigma, self.dim)
self.epsilon = u.convert_to(self.sigma/self.val, sp.numbers.Integer(1))
if self.epsilon == sp.zoo or self.epsilon == sp.oo or self.epsilon == sp.nan:
self.epsilon = np.nan
elif self.epsilon < 0:
self.epsilon = sp.Abs(self.epsilon)
elif epsilon is not None:
self.epsilon = np.float64(u.convert_to(epsilon, sp.numbers.Integer(1)))
if not np.isnan(self.epsilon) and self.epsilon < 0:
self.epsilon = np.abs(self.epsilon)
self.sigma = u.convert_to(self.val*self.epsilon, self.dim)
else:
if is_const:
self.sigma = self.epsilon = 0
else:
pass # TODO:last digit
self.is_const = is_const
if symbol is None:
if not hasattr(PQ, 'symbol_counter'):
PQ.symbol_counter = 0
else:
PQ.symbol_counter += 1
self.symbol = sp.symbols('symbol' + str(PQ.symbol_counter))
else:
self.symbol = sp.symbols(symbol)
def repr_as(self, dim):
"""
Конвертитует себя в размерность dim.
:returns себя
"""
self.dim = dim
self.val = u.convert_to(self.val, dim).n()
self.sigma = u.convert_to(self.sigma, dim).n()
return self
def convertTo(expr, unit):
"""Wraps units.convert_to for extra functionality.
Extra features:
Allows `unit` to be a string.
If `expr` has no units, returns `expr * unit`.
:param expr: sympy.Expr
:param unit: str\\units.Quantity\\units.Dimension
:return: sympy.Expr or None
"""
logger.log(logging.DEBUG - 1, f'convertTo({expr}, {unit})')
if expr is None:
return None
if isinstance(unit, str):
try:
unit = unitSubs[unit]
except KeyError:
unit = parseExpr(unit)
u = unit
logger.log(logging.DEBUG - 1, f'convertTo() expr {expr}, u {u}')
dim = getDimension(expr)
logger.log(logging.DEBUG - 1, f'convertTo() dim = {dim}')
if dim is None:
_ret = expr * u
if dim is not None and dim.name == 1:
_ret = expr * u
else:
_ret = units.convert_to(expr, u)
logger.log(logging.DEBUG - 1, f'convertTo() -> {str(_ret)}')
return _ret
def _convert_to_sec(self, val):
if val is not None:
try:
# sympy >= 1.1
return units.convert_to(val, units.seconds).args[0]
except Exception:
# sympy < 1.1
return val / units.seconds
return None
def _convert_to_sec(self, val):
if val is not None:
try:
# sympy >= 1.1
return units.convert_to(val, units.seconds).args[0]
except:
# sympy < 1.1
return val / units.seconds
return None
def __init__(self,
inlet=None,
outlet=None,
num_nodes=None,
teta=0,
length=None,
diameter=None,
epsilon=0,
ambient_t=None,
isotherm=True,
heat_transfer_coef=0):
self.inlet_stream = inlet
self.outlet_stream = outlet
self.D = np.array(convert_to(diameter, U.m).args[0], dtype=np.float32)
self.A = np.pi * self.D**2 / 4
self.teta = teta
self.epsilon = epsilon and np.array(convert_to(epsilon, U.m).args[0],
dtype=np.float32)
self.isotherm = isotherm
self.ambient_T = ambient_t and np.array(
convert_to(ambient_t, U.K).args[0], dtype=np.float32)
self.U = heat_transfer_coef and np.array(convert_to(
heat_transfer_coef, U.W / ((U.m**2) * U.K)).args[0],
dtype=np.float32)
self.domain = Domain(
np.array(convert_to(length, U.m).args[0], dtype=np.float32),
num_nodes + 2)
# define domain var and their boundry conditions
DomainVar('P', self.domain, (0, self.inlet_stream.P))
DomainVar('m', self.domain, (0, self.inlet_stream.m))
DomainVar('T', self.domain, (0, self.inlet_stream.T))
# intial conditions
self.domain.P[:] = self.inlet_stream.P
self.domain.m[:] = self.inlet_stream.m
self.domain.T[:] = self.inlet_stream.T
self.ps = PropertySet()
self.ps.P = self.domain.P
self.ps.T = self.domain.T
self.ps.MW = inlet.MW
self.pc = PipePropertyCalculator(self.ps, self)
def get_expr_without_units(expr, to, units_map):
"""Converts an expression with units to one without, applying conversion factors where necessary"""
expr = sympy_units.convert_to(expr, to)
subs = []
for s in units_map:
if type(s) == str:
subs.append((Symbol(s) * to, Symbol(s)))
else: #assume symbol
subs.append((s * to, s))
return expr.subs(subs)
def test_binary_information():
assert convert_to(kibibyte, byte) == 1024*byte
assert convert_to(mebibyte, byte) == 1024**2*byte
assert convert_to(gibibyte, byte) == 1024**3*byte
assert convert_to(tebibyte, byte) == 1024**4*byte
assert convert_to(pebibyte, byte) == 1024**5*byte
assert convert_to(exbibyte, byte) == 1024**6*byte
assert kibibyte.convert_to(bit) == 8*1024*bit
assert byte.convert_to(bit) == 8*bit
a = 10*kibibyte*hour
assert convert_to(a, byte) == 10240*byte*hour
assert convert_to(a, minute) == 600*kibibyte*minute
assert convert_to(a, [byte, minute]) == 614400*byte*minute
def eval(dim, lambd, *args, symbol=None):
"""
Вычисляет новую PE по формуле и пересчитывает погрешности как надо.
:param dim: Размерность желаемой величины.
:param lambd: Функция, которая будет вычисляться. Обычно в виде лямбды.
:param args: Параметры, которые надо передавать функции.
:param symbol: можно особо указать sympy символ (зачем?)
:return: Новое PQ.
"""
args = list(args)
log.debug('args: %s', args)
log.debug("Initial args types: %s"%str([type(arg) for arg in args]))
for i in range(len(args)):
if issubclass(type(args[i]), np.ndarray):
if type(args[i][0]) is not PQ:
args[i] = pqarray([PQ(val, is_const=True) for val in args[i]])
elif type(args[i]) is not PQ:
args[i] = PQ(args[i], is_const=True)
log.debug('args converted to PQ: %s', args)
partdiffs = [sp.diff(lambd(*[arg.symbol for arg in args]), x.symbol) for x in args]
log.debug('partdiffs %s', partdiffs)
values = {(arg.symbol, arg.val) for arg in args}
log.debug('values of partdiffs %s', values)
summands = [sp.Abs(partdiff.subs(values).evalf()**2*pe.sigma**2) for
(partdiff, pe) in zip(partdiffs, args)]
summands = [u.convert_to(s, dim**2) for s in summands]
log.debug('summands %s', summands)
new_val = u.convert_to(lambd(*[arg.val for arg in args]), dim).n()
log.debug('val %s', new_val)
new_sigma = u.convert_to(sp.sqrt(sum(summands)), dim).n()
log.debug('sigma %s', new_sigma)
log.debug('dim %s', dim)
return PQ(new_val, sigma=new_sigma, symbol=symbol, dim=dim)
def test_units():
assert convert_to((5*m/s * day) / km, 1) == 432
assert convert_to(foot / meter, meter) == Rational(3048, 10000)
# amu is a pure mass so mass/mass gives a number, not an amount (mol)
# TODO: need better simplification routine:
assert str(convert_to(grams/amu, grams).n(2)) == '6.0e+23'
# Light from the sun needs about 8.3 minutes to reach earth
t = (1*au / speed_of_light) / minute
# TODO: need a better way to simplify expressions containing units:
t = convert_to(convert_to(t, meter / minute), meter)
assert t == S(49865956897)/5995849160
# TODO: fix this, it should give `m` without `Abs`
assert sqrt(m**2) == Abs(m)
assert (sqrt(m))**2 == m
t = Symbol('t')
assert integrate(t*m/s, (t, 1*s, 5*s)) == 12*m*s
assert (t * m/s).integrate((t, 1*s, 5*s)) == 12*m*s
def print_unit_base(self, unit):
"""
Useless method.
DO NOT USE, use instead ``convert_to``.
Give the string expression of a unit in term of the basis.
Units are displayed by decreasing power.
"""
SymPyDeprecationWarning(
deprecated_since_version="1.2",
issue=13336,
feature="print_unit_base",
useinstead="convert_to",
).warn()
from sympy.physics.units import convert_to
return convert_to(unit, self._base_units)
def print_unit_base(self, unit):
"""
Useless method.
DO NOT USE, use instead ``convert_to``.
Give the string expression of a unit in term of the basis.
Units are displayed by decreasing power.
"""
SymPyDeprecationWarning(
deprecated_since_version="1.2",
issue=13336,
feature="print_unit_base",
useinstead="convert_to",
).warn()
from sympy.physics.units import convert_to
return convert_to(unit, self._base_units)
def test_convert_to():
q = Quantity("q1")
q.set_global_relative_scale_factor(S(5000), meter)
assert q.convert_to(m) == 5000 * m
assert speed_of_light.convert_to(m / s) == 299792458 * m / s
# TODO: eventually support this kind of conversion:
# assert (2*speed_of_light).convert_to(m / s) == 2 * 299792458 * m / s
assert day.convert_to(s) == 86400 * s
# Wrong dimension to convert:
assert q.convert_to(s) == q
assert speed_of_light.convert_to(m) == speed_of_light
expr = joule * second
conv = convert_to(expr, joule)
assert conv == joule * second
def canonicalize(expr, base=None):
"""Convert all units to given base units (default: SI base units)
Parameters
----------
expr :
base :
(Default value = None)
Returns
-------
"""
if base is None:
base = (spu.m, spu.kg, spu.s, spu.A, spu.K, spu.mol, spu.cd)
return spu.convert_to(expr, base)
def test_conversion_with_2_nonstandard_dimensions():
good_grade = Quantity("good_grade")
kilo_good_grade = Quantity("kilo_good_grade")
centi_good_grade = Quantity("centi_good_grade")
kilo_good_grade.set_global_relative_scale_factor(1000, good_grade)
centi_good_grade.set_global_relative_scale_factor(S.One/10**5, kilo_good_grade)
charity_points = Quantity("charity_points")
milli_charity_points = Quantity("milli_charity_points")
missions = Quantity("missions")
milli_charity_points.set_global_relative_scale_factor(S.One/1000, charity_points)
missions.set_global_relative_scale_factor(251, charity_points)
assert convert_to(
kilo_good_grade*milli_charity_points*millimeter,
[centi_good_grade, missions, centimeter]
) == S.One * 10**5 / (251*1000) / 10 * centi_good_grade*missions*centimeter
def canonicalize(expr, base=None):
"""Convert all units to given base units (default: SI base units)"""
if base is None:
base = (spu.m, spu.kg, spu.s, spu.A, spu.K, spu.mol, spu.cd)
return spu.convert_to(expr, base)
circuito, análisis_en_netlist)
resultados = ahkab.run(circuito, lista_de_análisis)
# %% [markdown]
# Imprimos los resultados del análisis `.op`:
# %%
print(resultados['op'])
# %% [markdown]
# Los cantidades `V1`, `V2` y `V3` hacen referencia a los distintos valores del potencial que se ha perdido en cada uno de los bornes que has elegido para describir el netlist (`1`, `2`, etc.). Por ejemplo, podemos calcular el *potencial consumido* por la resistencia `R1` y verás que coincide con el del punto `V2` devuelto por Ahkab.
# %%
r1 = 3E3 * u.ohms
intensidad_ahkab = resultados['op']['I(V1)'][0][0] * u.ampere
v2 = convert_to(intensidad_ahkab * r1, [u.volt])
pprint(v2)
# %% [markdown]
# > **Pregunta**: reproduce el resto de los valores anteriores de manera *manual* mediante Sympy (es decir, aplicando la ley de Ohm, pero con tun *toque computacional*). Te pongo aquí un ejemplo del que puedes partir… En él sólo calculo la corriente que circula por el circuito (sí, justo la que antes Ahkab ha devuelto de manera automática). Para ello necesito previamente computar la resistencia total (`r_total`). Faltarían el resto de resultados y convertirlos a unidades más *vistosas* (mediante la orden `convert_to` y `.n()`).
# %%
v1 = 9 * u.volts
r1 = 3 * u.kilo * u.ohms
r2 = 10 * u.kilo * u.ohms
r3 = 5 * u.kilo * u.ohms
r_total = r1 + r2 + r3
intensidad = u.Quantity('i')
intensidad.set_dimension(u.current)
ley_ohm = Eq(v1, intensidad * r_total)
solucion_para_intensidad = solve(ley_ohm, intensidad)
# Ejercicio basado en https://docs.sympy.org/latest/modules/physics/units/examples.html#equation-with-quantities
# Sobre Kepler https://en.wikipedia.org/wiki/Johannes_Kepler
from sympy import solve, symbols, pi, Eq # Cargamos objetos directos de Sympy
# Unidades S.I.
from sympy.physics.units import meter, kilogram, second, kelvin, newton, day, year
# Cargamos la función convert_to para pasar de unas unidades a otras
from sympy.physics.units import convert_to
# Cargamos constantes
# La constante de gravitación universal https://www.google.com/search?q=gravitational+constant
from sympy.physics.units import gravitational_constant as G
from sympy.physics.units import speed_of_light as c
T = symbols("T") # Incógnita: periodo de giro (T)
a = 108208000e3 * meter # Dato conocido: semieje mayor de Venus
M0 = 1.9891e30 * kilogram # Dato conocido: masa del Sol
eq_kepler = Eq(T**2 / a**3, 4 * pi**2 / G / M0) # Ecuación de Kepler
# Despejamos T, el resultado acaba en otra variable llamada "solution"
solution = solve(eq_kepler, T)[1]
# print(solution)
print(convert_to(solution, [year]).n())
# Conversión entre unidades https://docs.sympy.org/latest/modules/physics/units/quantities.html
#print(convert_to(G, [newton, meter, kilogram]))
from sympy.functions import *
from sympy.interactive import init_printing
from sympy.physics.units import Quantity
from sympy.physics.units import convert_to
from utils import *
init_printing()
hp_to_watts = 745.7
W0 = Quantity("W0")
W = Quantity("W")
m = Quantity("m")
v = Quantity("v")
g = Quantity("g")
theta = symbols("theta")
set_quantity(W0, un.power, 85 * hp_to_watts * un.watts)
set_quantity(W, un.power, 20 * hp_to_watts * un.watts)
set_quantity(m, un.mass, 1200 * un.kg)
set_quantity(v, un.velocity, 48 * un.km / un.hour)
set_quantity(g, un.acceleration, 9.81 * un.m / un.s**2)
eq = Eq(sin(theta), (W0 - W) / (m * g * v))
pretty_print(eq)
theta = solve(eq, theta)[1]
theta = convert_to(theta, un.watts).n()
pretty_print(convert_to(theta, un.degrees).n())
def add_sigma(self, other_sigma):
self.sigma = sp.sqrt(self.sigma**2 + other_sigma**2)
self.epsilon = u.convert_to(self.sigma/self.val, sp.numbers.Integer(1))
return self
import sympy.physics.units as un
from sympy import symbols, Eq, pretty_print
from sympy.interactive import init_printing
from sympy.physics.units import Quantity
from sympy.physics.units import convert_to
from utils import *
init_printing()
E = Quantity("E")
c = Quantity("c")
set_quantity(E, un.energy, 2.15e12 * un.kilo * un.watts * un.hour)
set_quantity(c, un.speed, 3.00e8 * un.m / un.s)
E = convert_to(E, un.joule).n()
print('Heavy water:')
pretty_print(Eq(symbols('D2O'), 2 * symbols('D') + symbols('O')))
print('Let nucleosynthesis reaction be like below:')
pretty_print(Eq(symbols('D'), symbols('H_^2')))
pretty_print(Eq(symbols('H^2') + symbols('H^2'), symbols('He_^4')))
print('a).')
m = symbols('m')
pretty_print(Eq(m, symbols('E') / c**2))
m = E / c**2
m = convert_to(m, un.kg).n()
pretty_print("Energy to mass : {}".format(m))
from sympy.physics import units
# Convert 12 inches to meters
D = units.convert_to(12 * units.inch, units.meter)
# Convert 0.2 mg/L to kg/m3
C = units.convert_to(0.2 * units.mg / units.l, units.kg / units.m**3)
# Convert 30 psi to m (assuming density = 1000 kg/m3 and gravity = 9.81 m/s2)
P = 30 * units.psi
P = units.convert_to(P, units.Pa) # convert psi to pascal
waterpressure = 9810 * units.Pa / units.m
H = P / waterpressure # convert pascal to m
# Convert 200 gallons/day to m3/day
if not 'gallon' in units.find_unit('volume'):
units.gallon = 4 * units.quart
R = units.convert_to(200 * units.gallon / units.day, units.m**3 / units.day)
def test_conversion_to_from_si():
assert convert_to(statcoulomb, coulomb,
cgs_gauss) == 5 * coulomb / 149896229
assert convert_to(coulomb, statcoulomb,
cgs_gauss) == 149896229 * statcoulomb / 5
assert convert_to(
statcoulomb,
sqrt(gram * centimeter**3) / second,
cgs_gauss) == centimeter**(S(3) / 2) * sqrt(gram) / second
assert convert_to(
coulomb,
sqrt(gram * centimeter**3) / second,
cgs_gauss) == 149896229 * centimeter**(S(3) /
2) * sqrt(gram) / (5 * second)
# SI units have an additional base unit, no conversion in case of electromagnetism:
assert convert_to(coulomb, statcoulomb, SI) == coulomb
assert convert_to(statcoulomb, coulomb, SI) == statcoulomb
# SI without electromagnetism:
assert convert_to(erg, joule, SI) == joule / 10**7
assert convert_to(erg, joule, cgs_gauss) == joule / 10**7
assert convert_to(joule, erg, SI) == 10**7 * erg
assert convert_to(joule, erg, cgs_gauss) == 10**7 * erg
assert convert_to(dyne, newton, SI) == newton / 10**5
assert convert_to(dyne, newton, cgs_gauss) == newton / 10**5
assert convert_to(newton, dyne, SI) == 10**5 * dyne
assert convert_to(newton, dyne, cgs_gauss) == 10**5 * dyne
SI.set_quantity_dimension(s, length**2) SI.set_quantity_scale_factor(s, 35.0 * un.cm**2) SI.set_quantity_dimension(h1, length) SI.set_quantity_scale_factor(h1, 2.4 * un.meters) SI.set_quantity_dimension(h2, length) SI.set_quantity_scale_factor(h2, 4.8 * un.meters) SI.set_quantity_dimension(g, acceleration) SI.set_quantity_scale_factor(g, 9.81 * un.m / un.s**2) SI.set_quantity_dimension(etha, One) SI.set_quantity_scale_factor(etha, 0.6) SI.set_quantity_dimension(theta, One) SI.set_quantity_scale_factor(theta, 30 * un.degrees) eq1 = Eq(etha * Wo, rho * s * v * g * h1 + rho * s * v * v**2 / 2) eq2 = Eq(v**2, 8 * g * h2) # eq2 = Eq((v * sin(theta))**2, 2*g*h2) pretty_print(eq1) pretty_print(eq2) res = solve((eq1, eq2), (v, Wo))[1][1] pretty_print(res) pretty_print(convert_to(res, un.watts).n())
def check_unit_compatibility(rhs_units, lhs_units):
try:
assert sympy_units.convert_to(rhs_units + lhs_units, lhs_units)
except:
raise NameError('incompatible units:{} and {}'.format(
lhs_units, rhs_units))
def set_epsilon(self, epsilon):
self.epsilon = u.convert_to(epsilon, sp.numbers.Integer(1))
self.sigma = u.convert_to(self.val*self.epsilon, self.dim)
return self
moments_of_inertia_slices = 8 / 15 * np.pi * moments_of_inertia_slices
pretty_print(moments_of_inertia_slices)
# sum slices up:
I_m5_g_per_cm3 = np.sum(moments_of_inertia_slices)
print('I_ns = {} m^5*g/cm^3'.format(I_m5_g_per_cm3))
# Moment of inertia of the Earth relative to NS axis
I_ns = get_quantity(
Quantity("I_ns"),
un.mass * un.length ** 2,
I_m5_g_per_cm3 * un.m ** 5 * un.gram / un.cm ** 3
)
print("a)")
pretty_print(Eq(Symbol("I_ns"), convert_to(I_ns, un.kg * un.m ** 2).n()))
print("b)")
# angular speed of the Earth, rad/s:
omega = get_quantity(
Quantity("omega"),
np.angle / un.time, 2 * np.pi / (24 * 3600) * un.radians / un.second
)
# angular momentum of the Earth:
L = I_ns * omega
pretty_print(
Eq(symbols("L"),
convert_to(L, un.kg * un.m ** 2 / un.s).n())
)
# %%
print(resultados['op'])
# %% [markdown]
# Los cantidades `V1`, `V2` y `V3` hacen referencia a los distintos valores del potencial que se ha perdido en cada uno de los bornes que has elegido para describir el netlist (`1`, `2`, etc.). Por ejemplo, podemos calcular el *potencial consumido* por la resistencia `R1` y verás que coincide con el del punto `V2` devuelto por Ahkab. **Ejercicio**: compruébalo tú mismo y refléjalo por escrito.
# %% [markdown]
# Cargamos primero todo lo relacionado con Sympy:
# %%
# %%
r1 = 3E3*ohms
intensidad_ahkab = resultados['op']['I(V1)'][0][0]*amperes
v2 = convert_to(intensidad_ahkab*r1, [volts])
v2
# %% [markdown]
# > **Pregunta**: reproduce el resto de los valores anteriores de manera *manual* mediante Sympy (es decir, aplicando la ley de Ohm, pero con un *toque computacional*). Te pongo aquí un ejemplo del que puedes partir… En él sólo calculo la corriente que circula por el circuito (sí, justo la que antes Ahkab ha devuelto de manera automática). Para ello necesito previamente computar la resistencia total (`r_total`). Faltarían el resto de resultados y convertirlos a unidades más *vistosas* (mediante la orden `convert_to` y `.n()`).
# %%
v1 = 9*volts
r1 = 3*kilo*ohms
r2 = 10*kilo*ohms
r3 = 5*kilo*ohms
r_total = r1 + r2 + r3
intensidad = symbols('i')
ley_ohm = Eq(v1, intensidad*r_total)
solucion_para_intensidad = solve(ley_ohm, intensidad)
convert_to(solucion_para_intensidad[0], [amperes]).n(2)
def test_issue_quart():
assert convert_to(4 * quart / inch ** 3, meter) == 231
assert convert_to(4 * quart / inch ** 3, millimeter) == 231
from sympy import symbols, solve, Eq, pretty_print
from sympy.physics.units import Quantity, mass, acceleration, power, velocity
from sympy.physics.units import convert_to
from sympy.physics.units import kilo
from sympy.physics.units import km, hour, m, s, kg, W
from sympy.physics.units.systems import SI
a = symbols("a")
m_ = Quantity("m")
v = Quantity("v")
W_ = Quantity("W")
SI.set_quantity_dimension(a, acceleration)
SI.set_quantity_dimension(m_, mass)
SI.set_quantity_scale_factor(m_, 1000*kg)
SI.set_quantity_dimension(v, velocity)
SI.set_quantity_scale_factor(v, 60*km/hour)
SI.set_quantity_dimension(W_, power)
SI.set_quantity_scale_factor(W_, 120*kilo*W)
eq = Eq(W_, m_*a*v)
result = solve(eq, a)[0]
pretty_print(result)
pretty_print(convert_to(result, m / s ** 2).n())
def set_sigma(self, sigma):
self.sigma = u.convert_to(sigma, self.dim)
self.epsilon = u.convert_to(self.sigma/self.val, sp.numbers.Integer(1))
return self
def __init__(self, P, T, m, MW):
self.P = np.array(convert_to(P, U.pa).args[0], dtype=np.float32)
self.T = np.array(convert_to(T, U.K).args[0], dtype=np.float32)
self.m = np.array(convert_to(m, U.kg / U.s).args[0], dtype=np.float32)
self.MW = np.array(convert_to(MW, U.kg / U.mol).args[0],
dtype=np.float32)
