如何编写一个算法，给定一个浮点数，并尝试使用分子和分母（两者都限制在 Java 字节的范围内）尽可能准确地表示？
原因是 I2C 设备需要分子和分母，而给它一个浮点数是有意义的。
例如，3.1415926535...将导致245/78, 而不是314/100或22/7。
就效率而言，在程序开始时会调用大约三次，但之后就不再调用了。所以慢的算法也不算太糟糕。
我有一个以数字形式返回的值，可以是十进制数，例如“1.15”。
但是，我需要将一定范围内的所有数字格式化为给定的分数。例如，所有大于 0 但小于 0.2 的数字我想返回“1/8”。
我已经开始将其作为一系列 if/else 语句来执行此操作，但我想知道是否有更聪明、更简洁的方法。
if (amt > 0 && amt <= .2){
q = '1/8';
} else if (amt > .2 && amt <= .3){
q = '1/4';
} else if (amt > .3 && amt <= .4){
q = '1/3';
} else if (amt > .4 && amt <= .5){
q = '1/2';
} else if (amt > .5 && amt <= .7){
q = '2/3';
} else if (amt > .7 …是否有一种简单的方法来（尝试）合理化给定 delta 中表达式中的所有数值，就像Rationalize[]在 Mathematica 中一样？
Mathematica 中的一个例子：
In[25]:= Rationalize[0.5 x^2 - 3.333333 x, 10^-4]
Out[25]= x^2/2-(10 x)/3
我看到了这个nsimplify()功能，但这似乎有点矫枉过正。
我编写了这段代码来计算使用欧几里德算法的有理数N的连续分数展开:
from __future__ import division
def contFract(N):
while True:
yield N//1
f = N - (N//1)
if f == 0:
break
N = 1/f
如果说N是3.245,则函数永远不会结束,因为显然f永远不等于0.扩展的前10个术语是:
[3.0,4.0,12.0,3.0,1.0,247777268231.0,4.0,1.0,2.0,1.0]
这显然是一个错误,因为实际扩展只是:
[3; 4,12,3,1]或[3; 4,12,4]
是什么原因引起了这个问题？这是某种舍入错误吗？
python division integer-division fractions continued-fractions
我最近遇到了一个问题，我在 MSVC 中遇到了段错误，而在 GCC 中却没有。
几个小时后，我意识到显然我的 MSVC 版本不支持以下语法：
double value = 3.4;
double fractional = std::modf(value, nullptr);
我不想要/关心数字的整个部分。
是的，我知道我可以做“3.4 - 3.0”之类的，但我担心以这种方式专门使用 modf。目前我只能通过以下方式看到这样做：
double temp;
double value = 3.4;
double fractional = std::modf(value, &temp);
有没有办法绕过这个临时变量？
我需要正确的公式,将小时转换为分钟,反之亦然.我编写了一个代码,但它似乎没有按预期工作.例如:如果我有小时= 8.16,那么分钟应该是490,但我得到的结果为489.
import java.io.*;
class DoubleToInt {
public static void main(String[] args) throws IOException{
BufferedReader buff =
new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the double hours:");
String d = buff.readLine();
double hours = Double.parseDouble(d);
int min = (int) ((double)hours * 60);
System.out.println("Minutes:=" + min);
}
}
假设已经给出了这些功能:
include <stdio.h> /* printf */
include "fractions.h" /* struct FRACTION, add_fractions */
struct FRACTION make_fraction(int numerator, int denominator)
{
struct FRACTION f;
f.numerator = numerator;
f.denominator = denominator;
return f;
}
void test_fraction(int numerator1, int denominator1,
int numerator2, int denominator2)
{
struct FRACTION a = make_fraction(numerator1, denominator1);
struct FRACTION b = make_fraction(numerator2, denominator2);
struct FRACTION c = add_fractions(&a, &b);
printf("%i/%i + %i/%i = %i/%i\n", a.numerator, a.denominator,
b.numerator, b.denominator,
c.numerator, c.denominator);
}
void testGCD(void)
{
int m, n;
m = …我们需要将计算出的值(例如3.33333000540733337)转换为3 1/3.我试过的任何库如https://github.com/peterolson/BigRational.js都会将其转换为最准确的有理数,而我只关注近似有理数,到.01有效小数.
在ruby中,我们目前使用Rational(1.333).理性化(Rational(0.01)),它给出1作为整数,1作为分子,3作为分母.
对可能有用的算法的任何想法都会很棒.
在Python 3.52中进行从浮点类型到分数类型转换的主题的练习时，我发现了两种不同转换方式之间的区别。
第一种方法是：
>>> from fractions import Fraction
>>> x = 1232.23
>>> f = Fraction(*x.as_integer_ratio())
>>> print(f)
2709702426188841/2199023255552 #Answer
第二种方法是：
>>> from fractions import Fraction
>>> x = 1232.23
>>> f = Fraction(str(x))
>>> print(f)
123223/100 #Answer
我想知道这两个不同答案背后的原因吗？抱歉，如果这是一个愚蠢的问题，我是编程和Python的新手。
编辑：我找到了一种方法，可以将第一种方法获得的不精确分数转换为按limit_denominator方法精确：
>>> from fractions import Fraction
>>> x = 1232.23
>>> f = Fraction(*x.as_integer_ratio())
>>> f = f.limit_denominator(100)
>>> print(f)
123223/100