32-bit floating point math in 64-bit Python [duplicate]

Question

I program embedded software that runs 32-bit math in 32-bit hardware. I routinely investigate floating point imprecision issues.

In-target debugging is routine, but for convenience I'd like to be able to do quick calculations in my desktop Python environment, having it behave like the target, i.e, do the math in 32 bits.

The desktop hardware, the OS and the Python installation are 64-bit.

We're talking IEEE floats all around.

Ideally, after configuration, I'd like to be able to type, say, 0.1+0.2 at the Python interpreter and have it already know to process and store everything using 32-bit math.

What are my options?

Answer 1

Extending Yann Vernier's idea, this would be a possible transformer that injects a numpy import and wraps every float literal in numpy.float32.

import ast

class Float32Visitor(ast.NodeTransformer):
    def visit_Module(self, node):
        # add numpy import
        imp = ast.Import([ast.alias("numpy")])
        node.body = [imp] + node.body
        return node

    def visit_Num(self, node):
        if not isinstance(node.n, float):
            return node

        return ast.Call(
            func=ast.Attribute(
                value=ast.Name(id="numpy", ctx=ast.Load()),
                attr="float32", ctx=ast.Load()
            ),
            args=[node],
            keywords=[],
            starargs=None,
            kwargs=None
        )

Hooking this into compile is a bit tricky and hackish, however. To do it for a single piece of code, you'd do something like this:

import ast
parsed = ast.parse(my_code, "my_code.py", mode="exec")
parsed = Float32Visitor().visit(parsed)
code = compile(parsed, "my_code.py", mode="exec")
my_code = eval(code)