How can I create a workflow for physical unit safety in Python?

Question

I work for an engineering firm which builds most of our physics models in Excel with VBA. For myself and many other younger mechanical engineers in the company, this is not a good solution - we grew up with Python and Matlab and are more comfortable in those languages.

I've developed a script in Python to approximate the solutions to certain physics equations. I used a library called Pint to create each variable as an object containing both magnitude and a physical (e.g. foot, meter, kilogram) dimension. This let's me check that the correctness of my physics equations, which is extremely useful because a lot of physics errors can be caught by checking units. However, this leads to a lot of overhead (10x slowdown). As noted in a comment below, this is because Pint and similar libraries instantiate new objects every time an arithmetic calculation is performed.

Because myself and others will be frequently creating similar programs, I want want to create a process for ensuring that there are no unit errors in our programs (e.g., adding a [length] unit to a [time] unit, or failing to convert between Celsius and Kelvin). What approach can be used for this that do not incur excessive overhead?

Answer 1

What you want is

• a way to create user defined types (one type per dimension in a certain unit), with only certain conversions allowed between specific pairs of types

• typesafety with almost no overhead.

Sorry to say this, but Python (specifically the standard CPython implementation) and Matlab are the wrong programming languages for this (*). For this kind of requirements, languages like C++ or Rust are way better suited, but even Java or C# would give you easily a huge performance advantage (mostly because most of the type checking overhead happens during the compilation stage and not at run time).

So what can you do if you don't want to move completely away from the Python ecosystem? Some ideas:

• try to use Cython

• check if the PyPy can be used in your environment

• check if it helps to implement your module in C (or a "compatible" language with similar properties)

Of course, all of these approaches have their drawbacks, too. You have to check for yourself if those are suitable for you.

(*) Disclaimer to the nitpickers: when I write "languages" here, I mean this in the sense "the most popular implementations of those programming languages", not in the sense of "an abstract mathematical construct".