convert pint.Quantity to sympy.physics.units

[kompre]

Hello,

I would like to use pint along side the sympy package (read as I prefer to use pint, but sympy need its own object to function properly) and I was looking at the solution proposed in the issue 606.

I think that solution is not well suited for my needs because it doesn't convert the pint units in compatible sympy units, but just in free symbol, so that resulting expression cannot be simplified to a preferred unit (e.g. it wouldn't know that 1 m equal to 100 cm).

I worked upon that example and created a function that will convert a pint's Quantity to a sympy's Quantity:

import sympy, pint
import sympy.physics.units as sympy_units

def to_sympy(quantity: pint.Quantity):
    
    # divide and extract the magnitude from the units: it will generate a two elements tuple, where the first item will be the magnitude and the second ona a tuple of tuples; each nested tuple is composed by two elements, the unit proper and the exponent to which is elevated; the tuples are supposed to be multiplied together.
    
    magnitude, units = (1*quantity).to_tuple() # quantity is multiplied by 1 so that it is converted to pint.Quantity if pint.Unit is passed instead
    
    # for each unit (i.e. tuple), check if it exist in the sympy.physics.units module
    for ut in units:
        fullname = ut[0]
        shortname = f'{pint.Unit(fullname):~}'
        exponent = ut[1]
        
        # add a new unit if it doesn't exist
        if not hasattr(sympy_units, fullname):
            setattr(sympy_units, fullname, sympy_units.Quantity(fullname, abbrev = shortname))  # create the new sympy unit with full name
            setattr(sympy_units, shortname, getattr(sympy_units, fullname)) # create the alias with the shortname
        
        # multiply magnitude for the sympy units (create a sympy.core.Mul object)
        magnitude *= getattr(sympy_units, fullname)**exponent
        
    return magnitude

The function checks if a unit exist in the sympy module, add it if it is missing, and the convert to simpy's Quantity. This will take care of the unit that are multiple of default unit, which usually are already presents in pint, but not in sympy. For example the kilonewton is not a default unit in sympy module.

ur = pint.UnitRegistry()
a = 10*ur.kN
a

b= to_sympy(a)
b

b is a valid sympy's quantity and can be converted to N:

sympy_units.convert_to(b, sympy_units.newton)

The kilonewton is now been added to sympy_units module and is available as sympy_units.kilonewton and sympy_units.kN

This also works for derived units, such as density

density = ur.kN/ur.m**3
density

to_sympy(density)

To be extra juicy, I've extended the pint's Quantity and Unit following the example of the issue 606. Now pint quantity can be used directly in sympy expression:

from sympy import Eq, symbols

x = symbols('x')

sympy_units.convert_to(Eq(x, 3*ur.cm), sympy_units.meter)

I think I am onto something here, but needs some more polish. It seems to suit me well for my need, but don't know where it could broke (e.g. it doesn't handle the kgf because is not a simple prefix multiplied a unit in the module)

[hgrecco]

Cool! What I have found to be a solution to "but don't know where it could broke" is to add functionality in a piecewise manner. i.e. make a narrow list of what you want to support and build checkers for those. Then raise an Exception is a given check is not passed. You can always add more functionality once it is released, but is difficult to remove it (even if it is broken as people might depend on it).

Build a python package (pint-sympy) and release it!

[kompre]

Build a python package (pint-sympy) and release it!

I wish I was able to! But I'm not a developer, just an amateur at best, I wouldn't now how to properly prepare a package for publishing. I wouldn't feel comfortable thinking it's out in the wild, someone could use it? ;-)

Mine was merely a feature request, suggesting a low hanging solution (I hope) for compatibility, because I don't like to just ask for something without providing at least some effort of my own.

Maybe in the future I will consider publishing as a package, depending how much I'll get fed up with copying-pasting piece of code in my workflow.