blocks|key|2231976|text|使用BigDecimal而不是double。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2231977|BigDecimal+e+=+BigDecimal.ONE;
BigDecimal+fact+=+BigDecimal.ONE;

for(int+i=1;i<100;i%2B%2B)+{
++fact+=+fact.multiply(new+BigDecimal(i));

++e+=+e.add(BigDecimal.ONE.divide(fact,+new+MathContext(10000,+RoundingMode.HALF_UP)));
}|code-block|syntax|javascript|2231978|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html^0|2|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Use a <a href="http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html" rel="noreferrer">BigDecimal</a> instead of a double.

<pre><code>BigDecimal e = BigDecimal.ONE;
BigDecimal fact = BigDecimal.ONE;

for(int i=1;i&lt;100;i++) {
 fact = fact.multiply(new BigDecimal(i));

 e = e.add(BigDecimal.ONE.divide(fact, new MathContext(10000, RoundingMode.HALF_UP)));
}
</code></pre>

blocks|key|2238012|text|如果你从49数到1，而不是像现在这样从1数到49，你会得到更好的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2238013|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You will get better results if you count from 49 to 1 instead of 1 to 49 as now.

blocks|key|5347265|text|您的主要问题是double的精度非常有限。如果你想要任意的精度，你必须使用BigDecimal。你将遇到的下一个问题是long的有限范围，在阶乘中你很快就会超过这个范围--在那里你可以使用BigInteger。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5347266|entityMap^0|7|6|11|A|1N|4|2M|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

Your main problem is that <code>double</code> has very limited precision. If you want arbitrary precision, you'll have to use <code>BigDecimal</code>. The next problem you're going to run into is the limited range of <code>long</code> which you're going to exceed very quickly with the factorial - there you can use <code>BigInteger</code>.

blocks|key|5347278|text|您看过java.util.BigDecimal中的任意精度算法吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5347279|import+java.math.BigDecimal;
import+java.math.MathContext;
public+class+BigExp+{
++public+static+void+main(String[]+args)+{
BigDecimal+FIFTY+=new+BigDecimal("50");
BigDecimal+e+=+BigDecimal.ZERO;
BigDecimal+f+=+BigDecimal.ONE;
MathContext+context+=+new+MathContext(1000);

for+(BigDecimal+i=BigDecimal.ONE;+i.compareTo(FIFTY)<0;+i=i.add(BigDecimal.ONE))+{
++f+=+f.multiply(i,+context);
++e+=+e.add(i.divide(f,context),context);

++System.out.println("e+=+"+%2B+e);
}
++}
}|code-block|syntax|javascript|5347280|entityMap^0|3|K|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Have you taken a look at the arbitrary-precision arithmetic in <code>java.util.BigDecimal</code>?

<pre><code>import java.math.BigDecimal;
import java.math.MathContext;
public class BigExp {
 public static void main(String[] args) {
BigDecimal FIFTY =new BigDecimal("50");
BigDecimal e = BigDecimal.ZERO;
BigDecimal f = BigDecimal.ONE;
MathContext context = new MathContext(1000);

for (BigDecimal i=BigDecimal.ONE; i.compareTo(FIFTY)&lt;0; i=i.add(BigDecimal.ONE)) {
 f = f.multiply(i, context);
 e = e.add(i.divide(f,context),context);

 System.out.println("e = " + e);
}
 }
}
</code></pre>

blocks|key|2232006|text|要理解为什么使用double无法获得“任何所需的精度”，请阅读这篇经典论文：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2232007|What+Every+Computer+Scientist+Should+Know+About+Floating-Point+Arithmetic|2232008|请注意，这是一篇非常技术性的论文。有关浮点数如何工作的更多基本细节，请参阅维基百科文章：Double+precision+floating-point+format|2232009|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.sun.com/source/806-3568/ncg_goldberg.html|1|http://en.wikipedia.org/wiki/Double_precision_floating-point_format^0|8|6|0|0|21|0|0|18|12|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|J|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

To understand why you cannot get "any desired precision" with <code>double</code>, read this classic paper:

<a href="http://docs.sun.com/source/806-3568/ncg_goldberg.html" rel="nofollow noreferrer">What Every Computer Scientist Should Know About Floating-Point Arithmetic</a>

Note that that's a quite technical paper. For more basic details of how floating-point numbers work, see this Wikipedia article: <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" rel="nofollow noreferrer">Double precision floating-point format</a>

blocks|key|2232015|text|使用Zed和mobrule的代码的变体。效果很好，谢谢！有没有人有更多的性能建议？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2232016|public+static+BigDecimal+factorial(int+x){
++++BigDecimal+prod+=+new+BigDecimal("1");
++++for(int+i+=+x;+i+>+1;+i--)
++++++++prod+=+prod.multiply(new+BigDecimal(i));
++++return+prod;
}//fact

public+static+void+main(String[]+args)+{
++++MathContext+mc+=+new+MathContext(1000);
++++BigDecimal+e+=+new+BigDecimal("1",+mc);
++++for(int+i+=+1;+i+<+1000;+i%2B%2B)
++++++++e+=+e.add(BigDecimal.ONE.divide(factorial(i),+mc));
++++System.out.print("e+=+"+%2B+e);
}//main+|code-block|syntax|javascript|2232017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Went with a variation of Zed and mobrule's code. Works great, thanks! More performance advice anyone?

<pre><code>public static BigDecimal factorial(int x){
 BigDecimal prod = new BigDecimal("1");
 for(int i = x; i &gt; 1; i--)
 prod = prod.multiply(new BigDecimal(i));
 return prod;
}//fact

public static void main(String[] args) {
 MathContext mc = new MathContext(1000);
 BigDecimal e = new BigDecimal("1", mc);
 for(int i = 1; i &lt; 1000; i++)
 e = e.add(BigDecimal.ONE.divide(factorial(i), mc));
 System.out.print("e = " + e);
}//main 
</code></pre>

blocks|key|3235360|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3235361|有更多的性能建议吗？|blockquote|3235362|3235363|3235364|是的，你的阶乘计算效率很低。更好的做法是把它移到循环中，在循环中对项求和。你这样做会把O(N)问题变成O(N%5E2)问题。|3235365|如果这是一个需要阶乘的真实计算，我建议使用查表或不完整的gamma函数作为正确的方法。|3235366|从性能的角度来看，您唯一可能做得更差的事情是递归阶乘计算。那么你就会有一个额外的问题，那就是一个巨大的堆栈。|3235367|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|O|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|R|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|S|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|T|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|U|7|@]|8|@]|9|$]]]|M|$]]

<blockquote>
 More performance advice anyone?
</blockquote>

Yes, your calculation of factorial is as inefficient as it gets. It would be better to move that inside the loop where you're summing the terms. The way you're doing things turns a O(N) problem into a O(N^2) problem.

And if this was a real calculation that needed factorials, I'd recommend a table lookup or the incomplete gamma function as the correct way to do it.

The only thing you could have done worse from a performance point of view is a recursive factorial calculation. Then you'd have the additional problem of a huge stack.

blocks|key|2238092|text|利用BigDecimal类可以得到e的最佳近似值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2238093|下面是计算给定BigDecimal值的代码|2238094|import+java.math.BigDecimal;
import+java.math.MathContext;


public+class+ApproximateE+{

++++public+static+void+main(String[]+args)+{
++++++++System.out.println("e~+"%2Be(new+BigDecimal(50)));//the+value+to+approximate

++++}

++++static+BigDecimal+e(BigDecimal+n)+{
++++++++BigDecimal+num+=+new+BigDecimal(n+%2B+"");
++++++++BigDecimal+e+=+BigDecimal.ZERO;
++++++++BigDecimal+f+=+BigDecimal.ONE;
++++++++MathContext+context+=+new+MathContext(25);//digits+of+precision

+++++++/************************************************************************
++++++++The+formula+for+approximating+e+~
++++++++e+=+1%2B(1/1!%2B1/2!%2B1/3!...1/i!)
+++++++************************************************************************/
++++++++for+(BigDecimal+i+=+BigDecimal.ONE;+i.compareTo(num)+<+0;+i+=+i.add(BigDecimal.ONE))+{

++++++++++++f+=+f.multiply(i,+context);
++++++++++++e+=+e.add(i.divide(f,+context),+context);

++++++++}
++++++++return+e;
++++}

}|code-block|syntax|javascript|2238095|返回：|2238096|e~+2.718281828459045235360289|2238097|F的值为|2238098|1
2
6
24
120
720
5040
40320
362880
3628800
39916800
479001600
6227020800
87178291200
1307674368000
20922789888000
355687428096000
6402373705728000
121645100408832000
2432902008176640000
51090942171709440000
1124000727777607680000
25852016738884976640000
620448401733239439360000
1.551121004333098598400000E%2B25
4.032914611266056355840000E%2B26
1.088886945041835216076800E%2B28
3.048883446117138605015040E%2B29
8.841761993739701954543616E%2B30
2.652528598121910586363085E%2B32
8.222838654177922817725564E%2B33
2.631308369336935301672180E%2B35
8.683317618811886495518194E%2B36
2.952327990396041408476186E%2B38
1.033314796638614492966665E%2B40
3.719933267899012174679994E%2B41
1.376375309122634504631598E%2B43
5.230226174666011117600072E%2B44
2.039788208119744335864028E%2B46
8.159152832478977343456112E%2B47
3.345252661316380710817006E%2B49
1.405006117752879898543143E%2B51
6.041526306337383563735515E%2B52
2.658271574788448768043627E%2B54
1.196222208654801945619632E%2B56
5.502622159812088949850307E%2B57
2.586232415111681806429644E%2B59
1.241391559253607267086229E%2B61
6.082818640342675608722522E%2B62|2238099|E的值为|2238100|1
2
2.5
2.666666666666666666666667
2.708333333333333333333334
2.716666666666666666666667
2.718055555555555555555556
2.718253968253968253968254
2.718278769841269841269841
2.718281525573192239858906
2.718281801146384479717813
2.718281826198492865159532
2.718281828286168563946342
2.718281828446759002314558
2.718281828458229747912288
2.718281828458994464285470
2.718281828459042259058794
2.718281828459045070516048
2.718281828459045226708118
2.718281828459045234928753
2.718281828459045235339785
2.718281828459045235359358
2.718281828459045235360248
2.718281828459045235360287
2.718281828459045235360289
2.718281828459045235360289
...|2238101|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

The best approximation of e can be got by using BigDecimal class.

Here is the code for computing the given BigDecimal Value

<pre><code>import java.math.BigDecimal;
import java.math.MathContext;


public class ApproximateE {

 public static void main(String[] args) {
 System.out.println("e~ "+e(new BigDecimal(50)));//the value to approximate

 }

 static BigDecimal e(BigDecimal n) {
 BigDecimal num = new BigDecimal(n + "");
 BigDecimal e = BigDecimal.ZERO;
 BigDecimal f = BigDecimal.ONE;
 MathContext context = new MathContext(25);//digits of precision

 /************************************************************************
 The formula for approximating e ~
 e = 1+(1/1!+1/2!+1/3!...1/i!)
 ************************************************************************/
 for (BigDecimal i = BigDecimal.ONE; i.compareTo(num) &lt; 0; i = i.add(BigDecimal.ONE)) {

 f = f.multiply(i, context);
 e = e.add(i.divide(f, context), context);

 }
 return e;
 }

}
</code></pre>

Returns :

<pre><code>e~ 2.718281828459045235360289
</code></pre>

The value of f is

<pre><code>1
2
6
24
120
720
5040
40320
362880
3628800
39916800
479001600
6227020800
87178291200
1307674368000
20922789888000
355687428096000
6402373705728000
121645100408832000
2432902008176640000
51090942171709440000
1124000727777607680000
25852016738884976640000
620448401733239439360000
1.551121004333098598400000E+25
4.032914611266056355840000E+26
1.088886945041835216076800E+28
3.048883446117138605015040E+29
8.841761993739701954543616E+30
2.652528598121910586363085E+32
8.222838654177922817725564E+33
2.631308369336935301672180E+35
8.683317618811886495518194E+36
2.952327990396041408476186E+38
1.033314796638614492966665E+40
3.719933267899012174679994E+41
1.376375309122634504631598E+43
5.230226174666011117600072E+44
2.039788208119744335864028E+46
8.159152832478977343456112E+47
3.345252661316380710817006E+49
1.405006117752879898543143E+51
6.041526306337383563735515E+52
2.658271574788448768043627E+54
1.196222208654801945619632E+56
5.502622159812088949850307E+57
2.586232415111681806429644E+59
1.241391559253607267086229E+61
6.082818640342675608722522E+62

</code></pre>

The value of e is 

<pre><code>1
2
2.5
2.666666666666666666666667
2.708333333333333333333334
2.716666666666666666666667
2.718055555555555555555556
2.718253968253968253968254
2.718278769841269841269841
2.718281525573192239858906
2.718281801146384479717813
2.718281826198492865159532
2.718281828286168563946342
2.718281828446759002314558
2.718281828458229747912288
2.718281828458994464285470
2.718281828459042259058794
2.718281828459045070516048
2.718281828459045226708118
2.718281828459045234928753
2.718281828459045235339785
2.718281828459045235359358
2.718281828459045235360248
2.718281828459045235360287
2.718281828459045235360289
2.718281828459045235360289
...
</code></pre>

I would like to approximate the value of e to any desired precision. What is the best way to do this? The most I've been able to get is e = 2.7182818284590455. Any examples on a modification of the following code would be appreciated.

<pre><code>public static long fact(int x){
 long prod = 1;
 for(int i = 1; i &lt;= x; i++)
 prod = prod * i;
 return prod;
}//fact

public static void main(String[] args) {
 double e = 1;
 for(int i = 1; i &lt; 50; i++)
 e = e + 1/(double)(fact(i));
 System.out.print("e = " + e);
}//main
</code></pre>

Better approximation of e with Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想要将e的值近似到任何所需的精度。做这件事最好的方法是什么？我能得到的最多是e= 2.7182818284590455。任何关于修改以下代码的示例都将受到欢迎。public static long fact(int x){ long prod = 1; for(int i = 1; i <= x; i++...

问用Java更好地逼近e
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用Java更好地逼近eEN