标签: integer-overflow

我糊涂了!

今天是11月3日

DateTime DateTime = new DateTime(2010,11,3);
long shazbot = 1000000000 * DateTime.Day;

shazbot出现在-1294967296

咦???

为什么当我在C#项目属性>构建>高级下打开"检查算术下溢/溢出"时,下面的代码运行得更快(138毫秒),而不是关闭选项(141毫秒)？

测试运行#1:138ms,带有检查算术,141ms没有

using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        var s = new Stopwatch();
        s.Start();
        int a = 0;
        for (int i = 0; i < 100000000; i += 3) {
            if (i == 1000)
                i *= 2;
            if (i % 35 == 0)
                ++a;
        }
        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds);
        Console.WriteLine(a);
    }
}

另一方面,如果您注释掉if (i == 1000) i *= 2;,则检查的代码比未检查的代码(116毫秒)运行得慢(120毫秒).

测试运行#2:120ms,带有检查算术,116ms没有

using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        var s …

来自GNU的网站:

-ftrapv
This option generates traps for signed overflow on addition, subtraction, multiplication operations. 
-fwrapv
This option instructs the compiler to assume that signed arithmetic overflow of addition, subtraction and multiplication wraps around using twos-complement representation. This flag enables some optimizations and disables others.

我有两个问题.1)哪些选项更适合性能？2)当-ftrapv定义说它产生"陷阱" 时,它意味着什么？这是否意味着例外？(我猜不是,但值得问.)

资料来源:https://gcc.gnu.org/onlinedocs/gcc-4.4.2/gcc/Code-Gen-Options.html

请考虑以下内容作为参考实现:

/* calculates (a * b) / c */
uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c)
{
    uint64_t x = a;
    x = x * b;
    x = x / c;
    return x;
}

我感兴趣的是一个不需要64位整数类型的实现(在C或伪代码中).

我开始草拟一个如下概述的实现:

/* calculates (a * b) / c */
uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c)
{
    uint32_t d1, d2, d1d2;
    d1 = (1 << 10);
    d2 = (1 << 10);
    d1d2 = (1 << 20); /* d1 * d2 */
    return ((a / d1) …

我正在尝试解决一个关于 SPOJ 的问题，它需要模幂运算。我正在使用以下 C 代码

long long modpow(long long a,long long b,long long mod)
{
    long long product,pseq;
    product=1
    pseq=a%mod;
    while(b>0)
    {
        if(b&1)
            product=(product*pseq)%mod;
        pseq=(pseq*pseq)%mod;
        b>>=1
    }
    return product;
}

问题是当我想计算时(2^249999999997)%999999999989，它会0因为溢出而给出答案。如何避免溢出？

有没有办法捕获整数异常，gfortran或者ifort像捕获浮点异常一样？

考虑这个简单的程序来计算阶乘：

program factorial
  use, intrinsic :: iso_fortran_env 

  implicit none
  integer(8)          :: fac
  real(REAL64)        :: facR
  integer,parameter   :: maxOrder = 30
  integer             :: i

  fac = 1 ; facR = 1.e0_REAL64
  do i=2,maxOrder
    fac=fac*i ; facR=facR*real(i,REAL64)
    write(*,*) i, fac, facR
  enddo ! i

end program

在某些时候会出现溢出 -integer(8)如此处所示，它将发生在 21 左右。但是如果没有使用浮点数作为参考的计算，我无法确定......

我刚刚开始学习 MIPS 指令的异常处理程序。

我需要使我的程序具有算术溢出异常，以便我可以测试我的异常处理程序。

我有两个数组 A 和 B。数组 A 有十六进制数，数组 B 有整数。

如何通过添加十六进制数和整数来使溢出？

哪些十六进制数和整数相加会导致溢出？

我正在开发一个 python 程序来计算斐波那契数列中的数字。这是我的代码：

import math
def F(n):
    return ((1+math.sqrt(5))**n-(1-math.sqrt(5))**n)/(2**n*math.sqrt(5))
def fib(n):
    for i in range(n):
        print F(i)

我的代码使用这个公式来查找斐波那契数列中的第 N 个数字：

这可以计算斐波那契数列中的许多数字，但我确实遇到了溢出错误。

如何改进此代码并防止溢出错误？

注意：我使用的是 python 2.7。

以下内容也适用于其他MIN_VALUE和，但我们现在MAX_VALUE只关注。Integer我知道在Java中整数是32位的，有Integer.MAX_VALUE = 2147483647(2 ³¹ -1)和Integer.MIN_VALUE = -2147483648(-2 ³¹ )。当使用这些值进行计算时，当超出其范围时，数字会环绕/溢出。因此，当您执行类似操作时Integer.MAX_VALUE + 1，结果与 相同Integer.MIN_VALUE。

MIN_VALUE以下是使用和 进行的一些基本算术计算MAX_VALUE：

Integer.MAX_VALUE:                      2147483647
Integer.MAX_VALUE + 1:                  -2147483648
Integer.MAX_VALUE - 1:                  2147483646
Integer.MAX_VALUE * 2:                  -2
Integer.MAX_VALUE * 3:                  2147483645
Integer.MAX_VALUE * 4:                  -4
Integer.MAX_VALUE * 5:                  2147483643
Integer.MAX_VALUE / Integer.MAX_VALUE:  1
Integer.MAX_VALUE * Integer.MAX_VALUE:  1
Integer.MAX_VALUE / Integer.MIN_VALUE:  0
Integer.MAX_VALUE * Integer.MIN_VALUE:  -2147483648
Integer.MAX_VALUE - Integer.MIN_VALUE:  -1
Integer.MAX_VALUE + Integer.MIN_VALUE: …

当然，这又花了 20 万年才发生。但是在 的值超过 的值后，Javascript约会系统会出错吗？会发生什么后果？Date.now()Number.MAX_SAFE_INTEGER

也许这个问题看起来很奇怪而且没用。但是任何人都可以回答我的好奇心以及其他可能有相同问题的人。