blocks|key|448463|text|你必须首先决定“几乎相同”是什么意思。例如，在java.lang.Math中有一个名为ulp()的方法，该方法在给定一个双精度值的情况下，返回该双精度值与下一个双精度值之间的距离；即，该数字与其他数字之间可能存在的最小差异。您可以简单地比较两个doubles之间的差异和调用该方法的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|448464|另一方面，也许你希望两个数字彼此之间只有1%25的误差。在这种情况下，执行相同的计算，但使用第一个数字乘以0.01而不是ulp()作为最大可接受距离。|448465|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/lang/Math.html#ulp%2528double%2529^0|N|E|17|5|0|0|1F|4|1M|5|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

You must first decide what "almost the same" means. For example, there's a method in <code>java.lang.Math</code> called <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Math.html#ulp%28double%29">ulp()</a> which, given a double, returns the distance between that double and the next; i.e., the smallest possible difference between that number and any other. You might simply compare the difference between the two doubles and the result of calling that method.

On the other hand, maybe you want two numbers to just be within 1% of eachother. In that case, do the same computation, but use the first number multiplied by <code>0.01</code> instead of <code>ulp()</code> as the largest acceptable distance.

blocks|key|448543|text|近似相等是用绝对差异来定义的:如果绝对差异不超过某个特定的、假设为小的数字，那么您可以说您正在比较的值“足够接近”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448544|double+diff+=+Math.abs(actual+-+expected);
if+(diff+<+1E-7)+{
++++//+Numbers+are+close+enough
}|code-block|syntax|javascript|448545|您必须非常小心，不要混淆“足够接近”和“等于”，因为这两者是根本不同的:相等是可传递的(例如，a==b和b==c一起表示a==c)，而“足够接近”不是可传递的。|448546|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Approximate equality is defined in terms of the absolute difference: if an absolute difference does not exceed a certain, presumably small, number, then you can say that the values you are comparing are "close enough".

<pre><code>double diff = Math.abs(actual - expected);
if (diff &lt; 1E-7) {
 // Numbers are close enough
}
</code></pre>

You must be very careful to not confuse "close enough" end "equals", because the two are fundamentally different: equality is transitive (i.e. a==b and b==c together imply that a==c), while "close enough" is not transitive.

blocks|key|662961|text|两个替身“大致相等”是什么意思？这意味着替身之间的容差在一定范围内。该公差的大小以及该公差是表示为绝对数还是表示为两个双精度数的百分比，取决于您的应用程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|662962|例如，如果显示在照片查看器上的两张照片在屏幕上占据相同的像素数，则它们的宽度以英寸为单位大致相同，因此您的容差将是基于屏幕像素大小计算的绝对数。另一方面，如果两家金融公司之间的利润在0.1%25以内，它们的利润可能“大致相等”。这些只是假设的例子，但重点是它取决于您的应用程序。|662963|现在来看一些实现。假设您的应用程序需要绝对的容错性。然后你就可以使用|662964|private+static+final+double+TOLERANCE+=+0.00001;

public+static+boolean+approxEqual(final+double+d1,+final+double+d2)+{
++++return+Math.abs(d1+-+d2)+<+TOLERANCE;
}|code-block|syntax|javascript|662965|来比较两个双精度数，并使用|662966|approxEqual(d1,+d2)+&&+approxEqual(d1,+d3)+&&+approxEqual(d1,+d4)+&&+approxEqual(d1,+d5)|662967|来比较五个双打。|662968|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

What does it mean for two doubles to be "approximately equal?" It means that the doubles are within some tolerance of each other. The size of that tolerance, and whether that tolerance is expressed as an absolute number or as a percentage of the two doubles, depends on your application.

For instance, two photos displayed on a photo viewer have approximately the same width in inches if they take up the same number of pixels on the screen, so your tolerance will be an absolute number calculated based on pixel size for your screen. On the other hand, two financial firms' profits are probably "approximately equal" if they are within 0.1% of each other. These are just hypothetical examples, but the point is that it depends on your application.

Now for some implementation. Let's say your application calls for an absolute tolerance. Then you can use

<pre><code>private static final double TOLERANCE = 0.00001;

public static boolean approxEqual(final double d1, final double d2) {
 return Math.abs(d1 - d2) &lt; TOLERANCE;
}
</code></pre>

to compare two doubles, and use

<pre><code>approxEqual(d1, d2) &amp;&amp; approxEqual(d1, d3) &amp;&amp; approxEqual(d1, d4) &amp;&amp; approxEqual(d1, d5)
</code></pre>

to compare five doubles.

blocks|key|662996|text|public+static+boolean+almostEqual(double+a,+double+b,+double+eps){
++++return+Math.abs(a-b)<eps;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|662997|其中，eps是平等的度量。|unstyled|662998|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>public static boolean almostEqual(double a, double b, double eps){
 return Math.abs(a-b)&lt;eps;
}
</code></pre>

Where eps is measure of equality.

blocks|key|663074|text|这取决于你所说的相似的意思。如果你想比较绝对误差范围内的两个数字，例如1e-6，你可以使用epsilon。如果您想要比较两个double而不考虑其规模。例如，1.1e-20和1.3e-20不相似，但1.1e20和1.1e20%2B1e5是可以比较的原始值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|663075|public+static+void+main(String...+args)+throws+IOException+{
++++test(1.1e-20,+1.3e-20);
++++test(1.1e20,+1.1e20+%2B+1e5);
}

private+static+void+test(double+a,+double+b)+{
++++System.out.println(a+%2B+"+and+"+%2B+b+%2B+",+similar=+"+%2B+similarUnscaled(a,+b,+10));
}

public+static+boolean+similarUnscaled(double+a,+double+b,+long+representationDifference)+{
++++long+a2+=+Double.doubleToRawLongBits(a);
++++long+b2+=+Double.doubleToRawLongBits(b);
++++//+avoid+overflow+in+a2+-+b2
++++return+((a2+>=+0)+==+(b2+>=+0))+&&
++++++++++++Math.abs(a2+-+b2)+<=+representationDifference;
}|code-block|syntax|javascript|663076|打印|663077|1.1E-20+and+1.3E-20,+similar=+false
1.1E20+and+1.100000000000001E20,+similar=+true|663078|entityMap^0|1Q|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

It depends on what you mean by similar. If you want to compare two numbers within an absolute error e.g. 1e-6 you can use epsilon. If you want to compare two <code>double</code> regardless of scale. e.g. 1.1e-20 and 1.3e-20 are not similar but 1.1e20 and 1.1e20+1e5 are you can compare the raw value.

<pre><code>public static void main(String... args) throws IOException {
 test(1.1e-20, 1.3e-20);
 test(1.1e20, 1.1e20 + 1e5);
}

private static void test(double a, double b) {
 System.out.println(a + " and " + b + ", similar= " + similarUnscaled(a, b, 10));
}

public static boolean similarUnscaled(double a, double b, long representationDifference) {
 long a2 = Double.doubleToRawLongBits(a);
 long b2 = Double.doubleToRawLongBits(b);
 // avoid overflow in a2 - b2
 return ((a2 &gt;= 0) == (b2 &gt;= 0)) &amp;&amp;
 Math.abs(a2 - b2) &lt;= representationDifference;
}
</code></pre>

prints

<pre><code>1.1E-20 and 1.3E-20, similar= false
1.1E20 and 1.100000000000001E20, similar= true
</code></pre>

I have a method in java that returns a double number and I want to compare every double number that is returned every time I call the method(say 5 times), so that I can conclude that the number returned is almost the same every time.

How can I do this?

How to compare that sequence of doubles are all "approximately equal" in Java?

我在java中有一个返回双精度数的方法，我想要比较每次调用该方法(比如5次)时返回的每个双精度数，这样我就可以得出结论，每次返回的数字几乎是相同的。我该怎么做呢？

问如何比较Java中doubles序列是否都“大致相等”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何比较Java中doubles序列是否都“大致相等”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何比较Java中doubles序列是否都“大致相等”？
EN