Here is my use case: recently implemented timedelta * float operation starts with converting float to an int ratio. The same algorithm can be used for decimals, but they don't support as_integer_ratio().

This seems like a reasonable request to me; I'd like to see a little bit of convergence between the float and Decimal APIs.

One difference between the two types that's worth noting is that the float.as_integer_ratio() method can never take a ridiculous amount of time or memory, whereas Decimal.as_integer_ratio() could: e.g., consider Decimal('1e999999999').as_integer_ratio(). But I don't really see that as a problem.

Here's a patch.

Updated patch, taking into account comments from merwok and exarkun on #python-dev:

• remove doctests for infinity and nan, replace with a sentence
  explaining what happens for such inputs.
• replace 'snAN' with saner spelling 'snan'.

Nice implementation. I wonder if the /5 loop can be eliminated by noting that /5 is *2 followed by decimal shift. (Probably not without fast decimal arithmetics.)

A few documentation nits:

1. In Decimal methods there is no consistency in referring to self. I see "given Decimal", "the number", and "the argument" in three entries around as_integer_ratio().

2. Is there a reason that docstring is more detailed than manual entry? I think the manual should describe exceptions.

3. Is there a reason to use different language for float.as_integer_ratio() and Decimal.as_integer_ratio()?

I know, ""A foolish consistency is the hobgoblin of little minds..." - feel free to ignore my observations.

A tiny code nit: to me it would be clearer to start with d2 = d5 = -self._exp after the "# Find d2, d5 ..." comment. For a moment I was puzzled why you promise d2 and d5, but then process d5 only.

Also, by the time of the "if not self" check, special case has been eliminated, so you can simply check self._int == 0.

Raymond, do you have any thoughts on this proposal?

-0 I don't think we really need this (we've already got a reasonable conversion to Fraction).

In general, we should have a aversion to adding any methods to the decimal API because it is already very fat. Adding more methods makes it harder to figure out which one is the right one to use.

Raymond,

conversion to Fraction does not really help in my use case of supporting timedelta * Decimal by duck typing. I can think of many other use cases where it will be helpful to accept either float or decimal without loss of precision. Is there an alternative way to achieve that which does not require importing the decimal module first?

After discussions on IRC, I'm going to close this as rejected. Convergence of the float and Decimal APIs is a nice idea, but in this case it's not clear that it really works. In particular, for duck typing to be sensible, int and Fraction would also have to grow an as_integer_ratio method. And that seems a superfluous when those two types already have the same functionality in the form of .numerator and .denominator attributes.

I also agree with Raymond that we shouldn't be fattening the decimal API without good reason.

Alexander: wouldn't conversion to Fraction solve the issue in this case? The Fraction constructor accepts floats, Decimal instances and ints directly.

Apologies: the title change was accidental. Reverted.

This issue has been superseded by bpo-25928.