blocks|key|309996|text|到目前为止，查找表将是最快、最精确的方法；只有大约600个10的幂可以表示为双倍。您可以使用哈希表，或者如果表是从最小到最大排序的，您可以使用二进制chop快速搜索它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|309997|这样做的好处是，当且仅当你的数字恰好是IEEE中最接近10的幂的倍数时，你才会得到一个“命中”。如果这不是你想要的，你需要更精确地知道你想要如何处理这样一个事实，即许多10的幂不能精确地表示为双精度。|309998|构造表的最好方法可能是使用字符串->浮点转换；这样，您的库作者可能已经解决了如何以一种尽可能精确的方式进行转换的问题。|309999|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

A lookup table will be by far the fastest and most precise way to do this; only about 600 powers of 10 are representable as doubles. You can use a hash table, or if the table is ordered from smallest to largest, you can rapidly search it with binary chop.

This has the advantage that you will get a "hit" if and only if your number is exactly the closest possible IEEE double to some power of 10. If this isn't what you want, you need to be more precise about exactly how you would like your solution to handle the fact that many powers of 10 can't be exactly represented as doubles.

The best way to construct the table is probably to use string -> float conversion; that way hopefully your library authors will already have solved the problem of how to do the conversion in a way that gives the most precise answer possible.

blocks|key|3266667|text|你的解决方案听起来不错，但我会用容忍度代替确切的比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3266668|double+exponent+=+log10(value);
double+rounded+=+floor(exponent+%2B+0.5);
if+(fabs(exponent+-+rounded)+<+some_tolerance)+{
++++//Power+of+ten
}|code-block|syntax|javascript|3266669|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|$]]

Your solution sounds good but I would replace the exact comparison with a tolerance one.

<pre><code>double exponent = log10(value);
double rounded = floor(exponent + 0.5);
if (fabs(exponent - rounded) &lt; some_tolerance) {
 //Power of ten
}
</code></pre>

blocks|key|3266739|text|bool+power_of_ten(double+x)+{
+++if(x+<+1.0+%7C%7C+x+>+10E15)+{
++++++warning("IEEE754+doubles+can+only+precisely+represent+powers+"
++++++++++++++"of+ten+between+1+and+10E15,+answer+will+be+approximate.");
+++}
+++double+exponent;
+++//+power+of+ten+if+log10+of+absolute+value+has+no+fractional+part
+++return+!modf(log10(fabs(x)),+&exponent);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3266740|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>bool power_of_ten(double x) {
 if(x &lt; 1.0 || x &gt; 10E15) {
 warning("IEEE754 doubles can only precisely represent powers "
 "of ten between 1 and 10E15, answer will be approximate.");
 }
 double exponent;
 // power of ten if log10 of absolute value has no fractional part
 return !modf(log10(fabs(x)), &amp;exponent);
}
</code></pre>

blocks|key|312941|text|根据平台的不同，您需要在日志上运行的代码可能会非常昂贵。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|312942|由于10%5En+(其中n是自然数)的数字数量非常少，因此只使用硬编码的查找表可能会更快。|312943|(丑陋的伪代码如下：)|312944|bool+isPowerOfTen(+int16+x+)
{
++if(+x+==+10+++++++//+n=1
++++%7C%7C+x+==+100+++++//+n=2
++++%7C%7C+x+==+1000++++//+n=3
++++%7C%7C+x+==+10000+)+//+n=4
++return+true;

++return+false;
}|code-block|syntax|javascript|312945|这涵盖了整个int16范围，如果这是您所需要的，那么速度可能会快得多。(取决于平台。)|312946|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Depending on the platform your code needs to run on the log might be very expensive.

Since the amount of numbers that are 10^n (where n is natural) is very small,
it might be faster to just use a hardcoded lookup table.

(Ugly pseudo code follows:)

<pre><code>bool isPowerOfTen( int16 x )
{
 if( x == 10 // n=1
 || x == 100 // n=2
 || x == 1000 // n=3
 || x == 10000 ) // n=4
 return true;

 return false;
}
</code></pre>

This covers the whole int16 range and if that is all you need might be a lot faster.
(Depending on the platform.)

blocks|key|3266716|text|如果你不想让它变得更快，可以使用递归。伪码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3266717|bool+checkifpoweroften(double+Candidadte)
+++++if+Candidate>=10
+++++++++return+(checkifpoweroften(Candidadte/10)+
+++++elsif+Candidate<=0.1
+++++++++return+(checkifpoweroften(Candidadte*10)
+++++elsif+Candidate+==+1
+++++++++return+1
+++++else+
+++++++++return+0|code-block|syntax|javascript|3266718|正如其他答案指出的那样，您仍然需要在假阳性和假阴性之间进行选择，并相应地添加容差。公差应适用于所有比较，否则，例如，9.99999999将无法通过>=10比较。|3266719|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|$]]

if you don't need it to be fast, use recursion. Pseudocode:

<pre><code>bool checkifpoweroften(double Candidadte)
 if Candidate&gt;=10
 return (checkifpoweroften(Candidadte/10) 
 elsif Candidate&lt;=0.1
 return (checkifpoweroften(Candidadte*10)
 elsif Candidate == 1
 return 1
 else 
 return 0
</code></pre>

You still need to choose between false positives and false negatives and add tolerances accordingly, as other answers pointed out. The tolerances should apply to all comparisons, or else, for exemple, 9.99999999 would fail the >=10 comparison.

blocks|key|312099|text|这个怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|312100|bool+isPow10(double+number,+double+epsilon)
{
++++if+(number+>+0)
++++{
++++++++for+(int+i=1;+i+<16;+i%2B%2B)
++++++++{
++++++++++++if+(+(number+>=+(pow((double)10,i)+-+epsilon))+&&+
++++++++++++++++(number+<=+(pow((double)10,i)+%2B+epsilon)))
++++++++++++{+
++++++++++++++++return+true;
++++++++++++}
++++++++}
++++}
++++return+false;
}|code-block|syntax|javascript|312101|我猜如果性能是一个问题，那么可以根据需要预先计算少数几个值，使用或不使用epsilon。|312102|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|$]]

how about that:

<pre><code>bool isPow10(double number, double epsilon)
{
 if (number &gt; 0)
 {
 for (int i=1; i &lt;16; i++)
 {
 if ( (number &gt;= (pow((double)10,i) - epsilon)) &amp;&amp; 
 (number &lt;= (pow((double)10,i) + epsilon)))
 { 
 return true;
 }
 }
 }
 return false;
}
</code></pre>

I guess if performance is an issue the few values could be precomputed, with or without the epsilon according to the needs.

blocks|key|312998|text|this+one的变体：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|312999|double+log10_value=+log10(value);
double+integer_value;
double+fractional_value=+modf(log10_value,+&integer_value);

return+fractional_value==0.0;|code-block|syntax|javascript|313000|请注意，与0.0的比较是精确的，而不是在特定的epsilon内，因为您希望确保log10_value是一个整数。|style|CODE|313001|编辑:由于log10可能不精确以及一般的理解是不应该在没有epsilon的情况下比较double，这引发了一些争议，这里有一个更精确的方法来确定double是否为10的幂，只使用10的幂和IEEE754+double的属性。|313002|首先，需要说明的是:一个双精度最多可以表示1E22，因为1e22只有52个有效位。幸运的是，5%5E22也只有52个有效位，所以我们可以确定double对于n=+[0,+22]是否为(2*5)%5En|313003|bool+is_pow10(double+value)
{
++++int+exponent;
++++double+mantissa=+frexp(value,+&exponent);

++++int+exponent_adjustment=+exponent/10;

++++int+possible_10_exponent=+(exponent+-+exponent_adjustment)/3;

++++if+(possible_10_exponent>=0+&&+
++++++++possible_10_exponent<=22)
++++{
++++++++mantissa*=+pow(2.0,+exponent+-+possible_10_exponent);

++++++++return+mantissa==pow(5.0,+possible_10_exponent);
++++}
++++else
++++{
++++++++return+false;
++++}
}|313004|由于2%5E10==1024，这增加了额外的重要性，我们必须从5的可能幂中删除。|313005|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2551657/c-how-can-i-test-if-a-number-is-power-of-ten/2551684#2551684^0|0|4|0|0|0|5|3|13|B|0|5|5|0|24|A|2H|7|0|0|2|A|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@$A|18|B|19|K|L]|$A|1A|B|1B|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1C|8|@$A|1D|B|1E|K|L]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1F|8|@$A|1G|B|1H|K|L]|$A|1I|B|1J|K|L]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1L|8|@$A|1M|B|1N|K|L]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

A variant of <a href="https://stackoverflow.com/questions/2551657/c-how-can-i-test-if-a-number-is-power-of-ten/2551684#2551684">this</a> one:

<pre><code>double log10_value= log10(value);
double integer_value;
double fractional_value= modf(log10_value, &amp;integer_value);

return fractional_value==0.0;
</code></pre>

Note that the comparison to <code>0.0</code> is exact rather than within a particular epsilon since you want to ensure that <code>log10_value</code> is an integer.

EDIT: Since this sparked a bit of controversy due to <code>log10</code> possibly being imprecise and the generic understanding that you shouldn't compare doubles without an epsilon, here's a more precise way of determining if a double is a power of 10 using only properties of powers of 10 and IEEE 754 doubles.

First, a clarification: a double can represent up to 1E22, as 1e22 has only 52 significant bits. Luckily, 5^22 also only has 52 significant bits, so we can determine if a double is <code>(2*5)^n</code> for <code>n= [0, 22]</code>:

<pre><code>bool is_pow10(double value)
{
 int exponent;
 double mantissa= frexp(value, &amp;exponent);

 int exponent_adjustment= exponent/10;

 int possible_10_exponent= (exponent - exponent_adjustment)/3;

 if (possible_10_exponent&gt;=0 &amp;&amp; 
 possible_10_exponent&lt;=22)
 {
 mantissa*= pow(2.0, exponent - possible_10_exponent);

 return mantissa==pow(5.0, possible_10_exponent);
 }
 else
 {
 return false;
 }
}
</code></pre>

Since <code>2^10==1024</code>, that adds an extra bit of significance that we have to remove from the possible power of 5.

I want to test if a number <code>double x</code> is an integer power of 10. I could perhaps use cmath's <code>log10</code> and then test if <code>x == (int) x</code>?

edit: Actually, my solution does not work because doubles can be very big, much bigger than int, and also very small, like fractions.

C++: how can I test if a number is power of ten?

我想测试一个数字是否是10的整数幂。我也许可以使用double x的log10，然后测试x == (int) x编辑：实际上，我的解决方案不起作用，因为doubles可以很大，比int大得多，也可以很小，比如分数。

问C++：如何测试一个数字是否是10的幂？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：如何测试一个数字是否是10的幂？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：如何测试一个数字是否是10的幂？
EN