blocks|key|2970042|text|浮点精度因机器和even+on+the+same+machine而异。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2970043|然而，.NET为你的应用程序创建了一个虚拟机...但是不同的版本会有所不同。|2970044|2970045|因此，您不应该依赖它来产生一致的结果。对于加密，请使用Framework提供的类，而不是使用自己的类。|2970046|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/16916073/the-microsoft-ace-driver-changes-the-floating-point-precision-in-the-rest-of-my^0|8|O|0|0|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|6|7|U|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|V|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Floating-point precision can vary from machine to machine, and <a href="https://stackoverflow.com/questions/16916073/the-microsoft-ace-driver-changes-the-floating-point-precision-in-the-rest-of-my">even on the same machine</a>.

<blockquote>
 However, the .NET make a virtual machine for your apps... but there are changes from version to version.
</blockquote>

Therefore you shouldn't rely on it to produce consistent results. For encryption, use the classes that the Framework provides rather than rolling your own.

blocks|key|2970083|text|你看到的是双精度的舍入误差。Math.Pow使用double，不同之处如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2970084|.NET+2.0和3.5+=>+var+powerResult+=+Math.Pow(ascii,+e);返回：|2970085|1.2308248131348429E%2B174|code-block|syntax|javascript|2970086|.NET+4.0和4.5+=>+var+powerResult+=+Math.Pow(ascii,+e);返回：|2970087|1.2308248131348427E%2B174|2970088|注意E前面的最后一个数字，这是导致结果不同的原因。这不是模运算符，，，(%25)。|BOLD|2970089|entityMap^0|E|8|0|G|11|0|0|G|11|0|0|2|1|Z|3|X|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|S]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|U|$]]

What you see is rounding error in double. <code>Math.Pow</code> works with double and the difference is as below:

.NET 2.0 and 3.5 => <code>var powerResult = Math.Pow(ascii, e);</code> returns:

<pre><code>1.2308248131348429E+174
</code></pre>

.NET 4.0 and 4.5 => <code>var powerResult = Math.Pow(ascii, e);</code> returns:

<pre><code>1.2308248131348427E+174
</code></pre>

Notice the last digit before <code>E</code> and that is causing the difference in the result. It's not the modulus operator <code>(%)</code>.

blocks|key|2757387|text|也许最好自己只用整数算术来计算它。类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2757388|int+n+=+143;
int+e+=+103;
int+result+=+1;
int+ascii+=+(int)+'a';

for+(i+=+0;+i+<+e;+%2B%2Bi)+
++++result+=+result+*+ascii+%25+n;|code-block|syntax|javascript|2757389|您可以将性能与其他答案中发布的BigInteger解决方案的性能进行比较。|2757390|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|$]]

Maybe it's best to calculate it yourself using only integer arithmetic. Something like:

<pre><code>int n = 143;
int e = 103;
int result = 1;
int ascii = (int) 'a';

for (i = 0; i &lt; e; ++i) 
 result = result * ascii % n;
</code></pre>

You can compare the performance with the performance of the BigInteger solution posted in the other answers.

blocks|key|162864|text|关于代码糟糕的方式，有很多答案。然而，对于为什么结果是不同的…|type|unstyled|depth|inlineStyleRanges|entityRanges|data|162865|英特尔的FPUs在内部使用80位格式，以获得更精确的中间结果。因此，如果一个值在处理器寄存器中，它将获得80位，但当它被写入堆栈时，它将被存储在64位中。|offset|length|style|BOLD|162866|我希望新版本的.NET在它的即时编译中有一个更好的优化器，所以它在寄存器中保留一个值，而不是将值写入堆栈，然后从堆栈中读回它。|162867|可能JIT现在可以在寄存器中返回值，而不是在堆栈中返回值。或者将该值传递给寄存器中的MOD函数。|162868|另请参阅堆栈溢出问题|162869|其他处理器，例如ARM，将对此代码给出不同的结果。|162870|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Floating-point_unit^0|0|D|3|20|3|4|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|G]]|9|@$D|13|E|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

There are a lot of answers about the way the code is bad. However, as to why the result is different…

Intel's <a href="https://en.wikipedia.org/wiki/Floating-point_unit" rel="nofollow noreferrer">FPUs</a> use the 80-bit format internally to get more precision for intermediate results. So if a value is in the processor register it gets 80 bits, but when it is written to the stack it gets stored at 64 bits.

I expect that the newer version of .NET has a better optimizer in its Just in Time (JIT) compilation, so it is keeping a value in a register rather than writing it to the stack and then reading it back from the stack.

It may be that the JIT can now return a value in a register rather than on the stack. Or pass the value to the MOD function in a register.

See also Stack Overflow question <a href="https://stackoverflow.com/questions/612507/what-are-the-applications-benefits-of-an-80-bit-extended-precision-data-type">What are the applications/benefits of an 80-bit extended precision data type?</a>

Other processors, e.g. the ARM will give different results for this code.

I am encrypting the user's input for generating a string for password. But a line of code gives different results in different versions of the framework. Partial code with value of key pressed by user:

Key pressed: 1. Variable <code>ascii</code> is 49. Value of 'e' and 'n' after some calculation:

<pre><code>e = 103, 
n = 143,

Math.Pow(ascii, e) % n
</code></pre>

Result of above code:

<ul>
<li>In .NET 3.5 (C#)

<pre><code>Math.Pow(ascii, e) % n
</code></pre>

gives <code>9.0</code>.</li>
<li>In .NET 4 (C#)

<pre><code>Math.Pow(ascii, e) % n
</code></pre>

gives <code>77.0</code>.</li>
</ul>

<code>Math.Pow()</code> gives the correct (same) result in both versions.

What is the cause, and is there a solution?

The modulo operator (%) gives a different result for different .NET versions in C#

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在对用户的输入进行加密，以生成密码字符串。但是一行代码在框架的不同版本中给出了不同的结果。用户按下键值的部分编码：按键: 1.变量ascii为49。经过计算后的'e‘和'n’的值：e = 103, n = 143,Math.Pow(ascii, e) % n上述代码的结果：.NET 3.5中的 (C#)Math.P...

问对于C#中的不同.NET版本，模运算符(%)给出不同的结果
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对于C#中的不同.NET版本，模运算符(%)给出不同的结果EN