Repository navigation
Expose PyFloat_AsDouble at Python level: operator.as_float? #84978
Description
| BPO | 40801 |
|---|---|
| Nosy | @mdickinson, @zware, @serhiy-storchaka |
| PRs |
Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.
Show more details
GitHub fields:
assignee = None
closed_at = None
created_at = <Date 2020-05-28.09:23:06.760>
labels = ['type-feature', '3.11']
title = 'Expose PyFloat_AsDouble at Python level: operator.as_float?'
updated_at = <Date 2021-06-21.12:00:00.034>
user = 'https://github.com/mdickinson'bugs.python.org fields:
activity = <Date 2021-06-21.12:00:00.034>
actor = 'serhiy.storchaka'
assignee = 'none'
closed = False
closed_date = None
closer = None
components = []
creation = <Date 2020-05-28.09:23:06.760>
creator = 'mark.dickinson'
dependencies = []
files = []
hgrepos = []
issue_num = 40801
keywords = ['patch']
message_count = 11.0
messages = ['370181', '370189', '370233', '370244', '370247', '370253', '370255', '370258', '370259', '370286', '396234']
nosy_count = 3.0
nosy_names = ['mark.dickinson', 'zach.ware', 'serhiy.storchaka']
pr_nums = ['20481', '26827']
priority = 'normal'
resolution = None
stage = 'patch review'
status = 'open'
superseder = None
type = 'enhancement'
url = 'https://bugs.python.org/issue40801'
versions = ['Python 3.11']
Activity
mdickinson commentedon May 28, 2020
Motivation
----------
Various pieces of Python need to do a duck-typed conversion of an arbitrary float-like object to a float (or a C double) for computation. The math module is the most obvious example - most math-module functions that accept a float also accept float-like things, like np.float32 and Decimal - but it's not the only place that this is needed.
This conversion is easy at C level, being encapsulated in a single function call: PyFloat_AsDouble. (Plus a PyFloat_FromDouble if you want to go back to Python space, of course.)
But: it's surprisingly awkward to get an equivalent effect in pure Python code. Options are:
Do an explicit type check to exclude str, bytes and bytearray, and then call the float constructor. But the extra type check is ugly and potentially not future-proof.
Call type(obj).__float__(obj). But this has several problems: __float__ can return an instance of a float subclass rather than a strict float, and then it's hard to convert to an actual float. And in more recent versions of Python, this no longer matches PyFloat_AsDouble because it doesn't account for objects that provide __index__ but not __float__. And calling dunder methods directly should rarely be the Right Way To Do It.
Use the implicit ability of the math module to do this, for example using math.copysign(obj, obj). This works! But it's not a clear expression of the intent.
This has bitten me in Real Code (TM), where I've needed a way to convert an arbitrary float-like thing to a float, ideally following the same rules that Python uses. And also ideally in such a way that my own code doesn't have to change if Python updates its rules, as for example it did recently to allow things with an __index__ to be considered float-like.
Proposal
--------
Add a new operator function "operator.as_float" which matches Python's duck-typed acceptance of float-like things, in the same way that the existing operator.index matches Python's implicit acceptance of int-like things in various APIs that expect integers.
Internally, "operator.as_float" would simply call PyFloat_AsDouble followed by PyFloat_FromDouble (possibly with a fast path to pass objects of exact type float through directly).
Related: bpo-17576.
[-]Expose PyFloat_ToDouble at Python level: operator.to_float?[/-][+]Expose PyFloat_ToDouble at Python level: operator.as_float?[/+][-]Expose PyFloat_ToDouble at Python level: operator.to_float?[/-][+]Expose PyFloat_ToDouble at Python level: operator.as_float?[/+]mdickinson commentedon May 28, 2020
Proof of concept in #64680
zware commentedon May 28, 2020
operatorseems a slightly odd place for this. My naive expectation would be thatfloat(floatlike_obj)should do what you want, but it seems that's not the case (too permissive of input types?). So then, what about an alternate constructor on the float object,float.from_floatlike(obj)? This could be implemented as effectively:which would work to get an instance of any float subclass after a round-trip through a double. I have no idea whether that's actually useful, though :)
mdickinson commentedon May 28, 2020
Yes, it's not ideal. It's by analogy with operator.index, which provides the equivalent duck-typing for integers, and calls __index__. Similarly, operator.as_float is primarily there to call __float__, except that now that PyFloat_AsDouble also makes use of __index__, it'll call that, too.
My other thought was putting this in math, since it's what the math module is already doing implicitly to most inputs.
An alternative float constructor could work. Though we then run into the messy question of what it should do for float subclasses ...
mdickinson commentedon May 28, 2020
On naming, maybe float.from_number or float.from_numeric?
serhiy-storchaka commentedon May 28, 2020
I think an alternative constructor is the best option. Some time ago I proposed to add more alternative constructors: https://mail.python.org/archives/list/python-ideas@python.org/thread/5JKQMIC6EUVCD7IBWMRHY7DRTTNSBOWG/
[-]Expose PyFloat_ToDouble at Python level: operator.as_float?[/-][+]Expose PyFloat_AsDouble at Python level: operator.as_float?[/+][-]Expose PyFloat_ToDouble at Python level: operator.as_float?[/-][+]Expose PyFloat_AsDouble at Python level: operator.as_float?[/+]serhiy-storchaka commentedon May 28, 2020
The problem with the roundtrip PyFloat_FromDouble(PyFloat_AsDouble(obj)) is that (in contrary to PyNumber_Index()) it is lossy. Converting Decimal, Fraction, float128 to float before using it in expression can lead to loss of precision.
So such conversion looks to me less useful than operator.index().
1 remaining item
mdickinson commentedon May 28, 2020
My experience is that this loss of precision is hardly ever a practical problem in the real world of scientific development; in practice floating-point numbers are almost universally IEEE 754 doubles (perhaps sometimes single-precision in large datasets, like seismic SEG-Y files; occasionally IBM format hex floats; but IEEE 754 doubles are by far the majority). It's very rare to be using float128 or Decimal or Fraction in practice for scientific data.
That's not to say that people outside that world won't be using these things, but there's a big ecosystem where float64 is pretty much all you need.
mdickinson commentedon May 29, 2020
I started a python-ideas thread: https://mail.python.org/archives/list/python-ideas@python.org/thread/3YGNHGWZOU5AIBS3A52CAHPJJLY7J2CS/
serhiy-storchaka commentedon Jun 21, 2021
PR 26827 is a draft for float.from_number() and complex.from_number().
skirpichev commentedon Oct 6, 2023
Since 3.7 it was deprecated (#71170) and maybe it's time to remove this (#109311).
So, it's not an issue in that part.
Then why not export
obj.__float__()asoperator.as_float. Same forobj.__complex__()(as_complex?) orobj.__int__()(as_int?) - all should return an appropriate type.Perhaps, a different constructor could be more discoverable option. But I don't see why we can't expose mentioned above dunder methods just as for the
__index__. Naming? (i.e. operator.as_float vs operator.float)pythongh-84978: expose __float__ dunder method as as_float
gh-84978: Add float.from_number() and complex.from_number() (GH-26827)
pythongh-84978: Add float.from_number() and complex.from_number() (py…
skirpichev commentedon Sep 19, 2024
@serhiy-storchaka, probably this can be closed?