GeezerVison is showing github.com — Expose PyFloat_AsDouble at Python level: operator.as_float? · Issue #84978 · python/cpython
Expose PyFloat_AsDouble at Python level: operator.as_float? #84978Description
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'] Linked PRs
Activitymdickinson commented on 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. changed the title [-]Expose PyFloat_ToDouble at Python level: operator.to_float?[/-] [+]Expose PyFloat_ToDouble at Python level: operator.as_float?[/+] on May 28, 2020changed the title [-]Expose PyFloat_ToDouble at Python level: operator.to_float?[/-] [+]Expose PyFloat_ToDouble at Python level: operator.as_float?[/+] on May 28, 2020mdickinson commented on May 28, 2020 zware commented on May 28, 2020 operator seems a slightly odd place for this. My naive expectation would be that float(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:
class float:
@classmethod
def from_floatlike(cls, obj):
return cls(PyFloat_FromDouble(PyFloat_AsDouble(obj)))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 commented on May 28, 2020
operator seems a slightly odd place for this.
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 commented on May 28, 2020 On naming, maybe float.from_number or float.from_numeric? serhiy-storchaka commented on May 28, 2020 changed the title [-]Expose PyFloat_ToDouble at Python level: operator.as_float?[/-] [+]Expose PyFloat_AsDouble at Python level: operator.as_float?[/+] on May 28, 2020changed the title [-]Expose PyFloat_ToDouble at Python level: operator.as_float?[/-] [+]Expose PyFloat_AsDouble at Python level: operator.as_float?[/+] on May 28, 2020serhiy-storchaka commented on 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(). mdickinson commented on May 28, 2020
Converting Decimal, Fraction, float128 to float before using it in expression can lead to loss of precision.
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 commented on May 29, 2020 serhiy-storchaka commented on Jun 21, 2021 PR 26827 is a draft for float.from_number() and complex.from_number(). skirpichev commented on Oct 6, 2023
- Call
type(obj).__float__(obj). But this has several problems: __float__ can return an instance of a float subclass
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.
calling dunder methods directly should rarely be the Right Way To Do It.
Then why not export obj.__float__() as operator.as_float. Same for obj.__complex__() (as_complex?) or obj.__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) skirpichev commented on Sep 19, 2024
MetadataMetadataDevelopmentNo branches or pull requestsIssue actions
|