# How to perform approximate structural pattern matching for floats and complex

``>>> sum([0.1] * 10) == 1.0 False >>> 1.1 + 2.2 == 3.3 False >>> sin(radians(45)) == sqrt(2) / 2 False ``

I also know how to work around these issues with math.isclose() and cmath.isclose().

The question is how to apply those work arounds to Python's match/case statement. I would like this to work:

``match 1.1 + 2.2: case 3.3: print('hit!') # currently, this doesn't match ``
• Be warned that `*.isclose` are heuristics, and can themselves fail in unexpected ways.
– TLW
Jun 13 at 23:48
• For instance, `math.isclose(a, b)` and `math.isclose(b, c)` but not `math.isclose(a, c)`. (E.g. with default settings, `a,b,c = 1, 1.0000000005, 1.0000000015`)
– TLW
Jun 13 at 23:52
• The isclose() functions have precise definitions and are completely controllable. They are offered by the standard library as the accepted way to make comparisons for nearby floats. No one made the claim that isclose() is transitive nor is that relevant to this use case — it is a red herring to create a vague and unactionable sense of worry. If there is a better solution, please post it.Jun 14 at 16:20

# Introducing: Trending sort

You can now choose to sort by Trending, which boosts votes that have happened recently, helping to surface more up-to-date answers.

Trending is based off of the highest score sort and falls back to it if no posts are trending.

The key to the solution is to build a wrapper that overrides the `__eq__` method and replaces it with an approximate match:

``import cmath class Approximately(complex): def __new__(cls, x, /, **kwargs): result = complex.__new__(cls, x) result.kwargs = kwargs return result def __eq__(self, other): try: return isclose(self, other, **self.kwargs) except TypeError: return NotImplemented ``

It creates approximate equality tests for both float values and complex values:

``>>> Approximately(1.1 + 2.2) == 3.3 True >>> Approximately(1.1 + 2.2, abs_tol=0.2) == 3.4 True >>> Approximately(1.1j + 2.2j) == 0.0 + 3.3j True ``

Here is how to use it in a match/case statement:

``for x in [sum([0.1] * 10), 1.1 + 2.2, sin(radians(45))]: match Approximately(x): case 1.0: print(x, 'sums to about 1.0') case 3.3: print(x, 'sums to about 3.3') case 0.7071067811865475: print(x, 'is close to sqrt(2) / 2') case _: print('Mismatch') ``

This outputs:

``0.9999999999999999 sums to about 1.0 3.3000000000000003 sums to about 3.3 0.7071067811865475 is close to sqrt(2) / 2 ``
• Since timestamps are floats, this should also work well for approximate times.Jun 13 at 7:50
• Minor note: A type-check of some sort would be needed in `__eq__` to make this work in mixed-type `match`es, e.g. adding `if not isinstance(other, numbers.Complex): return NotImplemented` (`Complex` is a superclass of `Real`, so it would support most numeric types aside from `decimal.Decimal`, which is a weirdo case) so it wouldn't die with a `TypeError` when the input might be non-numeric (because other `case`s are intended to catch non-numeric stuff).Jun 14 at 22:03

Raymond's answer is very fancy and ergonomic, but seems like a lot of magic for something that could be much simpler. A more minimal version would just be to capture the calculated value and just explicitly check whether the things are "close", e.g.:

``import math match 1.1 + 2.2: case x if math.isclose(x, 3.3): print(f"{x} is close to 3.3") case x: print(f"{x} wasn't close) ``

I'd also suggest only using `cmath.isclose()` where/when you actually need it, using appropriate types lets you ensure your code is doing what you expect.

The above example is just the minimum code used to demonstrate the matching and, as pointed out in the comments, could be more easily implemented using a traditional `if` statement. At the risk of derailing the original question, this is a somewhat more complete example:

``from dataclasses import dataclass @dataclass class Square: size: float @dataclass class Rectangle: width: float height: float def classify(obj: Square | Rectangle) -> str: match obj: case Square(size=x) if math.isclose(x, 1): return "~unit square" case Square(size=x): return f"square, size={x}" case Rectangle(width=w, height=h) if math.isclose(w, h): return "~square rectangle" case Rectangle(width=w, height=h): return f"rectangle, width={w}, height={h}" almost_one = 1 + 1e-10 print(classify(Square(almost_one))) print(classify(Rectangle(1, almost_one))) print(classify(Rectangle(1, 2))) ``

Not sure if I'd actually use a `match` statement here, but is hopefully more representative!

• ISTM that for match/case, a guards-only solution is an anti-pattern. You can always do better with an if-elif-else chain and would be better off abandoning match/case entirely rather than using guards only code. Note, the match/case specification was intentionally designed to support case clauses with float or complex literals. Essentially, this answer is a recommendation to not use that language feature at all. It seems like an objection to the language rather than demonstrating ways it can be used.Jun 14 at 16:29
• @RaymondHettinger can you explain a bit more? I thought the use of a match/case vs if/elif depends on the semantics you're trying to implement. Why does the matching expression matter in this decision? Is this a Python specific thing or a general idea your talking about?Jun 14 at 21:10
• @RaymondHettinger: When you say "always do better with if-elif-else chain", what do you mean? Your solution (which I up-voted) reduces code duplication in exchange for a little more magic-at-a-distance, but performance-wise they should be essentially identical (hypothetical hash-based `match`es can't optimize either; it'll always be equivalent to if-elif-else under the hood). You still get to pass a computed value to the `match` without prestoring it in a variable, you can still theoretically put in `case`s for other types, etc. Am I missing something that makes this fundamentally worse?Jun 14 at 21:59
• @RaymondHettinger: Would it look better with multiple `case x if math.isclose(x, some_float)` patterns? As it is, it could indeed be completely replaced with `if math.isclose(1.1 + 2.2, 3.3):`.Jun 15 at 7:13
• @RaymondHettinger sure, it can be substituted with `if-elif`, but why do it?Jun 15 at 16:31

You could also do a workaround with multiplying floats to an int.

If you have for example a float with just one decimal place, you can do this:

``a = 1.1 b = 2.2 def is_float_equal(a, b): match (a * 10) + (b * 10): case 33: print(f"{a} + {b} is 3.3.") case _: print(f"{a} + {b} is not 3.3.") ``