标签: integer-arithmetic

我有这个bash脚本,我在第16行遇到了问题.如何获取第15行的先前结果并将其添加到第16行的变量中？

#!/bin/bash

num=0
metab=0

for ((i=1; i<=2; i++)); do      
    for j in `ls output-$i-*`; do
        echo "$j"

        metab=$(cat $j|grep EndBuffer|awk '{sum+=$2} END { print sum/120}') (line15)
        num= $num + $metab   (line16)
    done
    echo "$num"
 done

我想得到的总和1 + 2 + ... + 1000000000,但我在PHP和Node.js得到了有趣的结果.

PHP

$sum = 0;
for($i = 0; $i <= 1000000000 ; $i++) {
    $sum += $i;
}
printf("%s", number_format($sum, 0, "", ""));   // 500000000067108992

Node.js的

var sum = 0;
for (i = 0; i <= 1000000000; i++) {
    sum += i ;
}
console.log(sum); // 500000000067109000

可以使用计算正确的答案

1 + 2 + ... + n = n(n+1)/2

正确答案= 500000000500000000,所以我决定尝试另一种语言.

走

var sum , i int64
for i = 0 …

我正在查看sorted_containers的来源,并惊讶地看到这一行:

self._load, self._twice, self._half = load, load * 2, load >> 1

这load是一个整数.为什么在一个地方使用位移,在另一个地方使用乘法？似乎合理的是,位移可能比积分除以2更快,但为什么不用乘法替换乘法呢？我对以下案例进行了基准测试:

1. (次,分)
2. (轮班,轮班)
3. (次,班次)
4. (转移,分裂)

并发现#3始终比其他替代品更快:

# self._load, self._twice, self._half = load, load * 2, load >> 1

import random
import timeit
import pandas as pd

x = random.randint(10 ** 3, 10 ** 6)

def test_naive():
    a, b, c = x, 2 * x, x // 2

def test_shift():
    a, b, c = x, x << 1, x >> 1    

def test_mixed(): …

我的程序中需要一些循环.我可以写出伪代码,但我不完全确定如何逻辑地编写它们.

我需要 -

if (num is a multiple of 10) { do this }

if (num is within 11-20, 31-40, 51-60, 71-80, 91-100) { do this }
else { do this } //this part is for 1-10, 21-30, 41-50, 61-70, 81-90

这是一个蛇和梯子棋盘游戏,如果它对我的问题更有意义.

我想第一个if语句我需要使用模数,是否if (num == 100%10)正确？

第二个我不知道.我可以写出来,if (num > 10 && num is < 21 || etc)但必须有比这更聪明的东西.

我遇到的代码来自一个似乎认为在结果为负时从另一个相同类型的整数中减去无符号整数的问题.因此,即使它恰好适用于大多数体系结构,这样的代码也是不正确的.

unsigned int To, Tf;

To = getcounter();
while (1) {
    Tf = getcounter();
    if ((Tf-To) >= TIME_LIMIT) {
        break;
    } 
}

这是我能找到的C标准中唯一含糊不清的引用.

涉及无符号操作数的计算永远不会过度流动,因为无法用结果无符号整数类型表示的结果将以比结果类型可以表示的最大值大1的数量为模.

我想人们可以接受这个引用来表示当右操作数较大时,操作被调整为在模数截断数字的上下文中有意义.

即

0x0000 - 0x0001 == 0x 1 0000 - 0x0001 == 0xFFFF

而不是使用依赖于实现的签名语义:

0x0000 - 0x0001 ==(无符号)(0 + -1)==(0xFFFF但也是0xFFFE或0x8001)

哪种或哪种解释是对的？是否定义了？

设a,b和c为非大正整数.a/b/c是否始终等于/(b*c)与C#整数运算？对我来说,在C#中它看起来像:

int a = 5126, b = 76, c = 14;
int x1 = a / b / c;
int x2 = a / (b * c);

所以我的问题是:x1 == x2为所有a,b和c做什么？

这个问题的动机是我在C/C++中实现加密算法(例如SHA-1),编写可移植平台无关的代码,并彻底避免未定义的行为.

假设标准化的加密算法要求您实现此目的:

b = (a << 31) & 0xFFFFFFFF

where a和b是无符号的32位整数.请注意,在结果中,我们丢弃高于最低32位的任何位.

作为第一个天真的近似,我们可以假设int在大多数平台上都是32位宽,所以我们写:

unsigned int a = (...);
unsigned int b = a << 31;

我们知道这个代码无处不在,因为int在某些系统上是16位宽,在其他系统上是64位,甚至可能是36位.但是使用stdint.h,我们可以使用以下uint32_t类型改进此代码:

uint32_t a = (...);
uint32_t b = a << 31;

所以我们完成了,对吧？这就是我多年来的想法.... 不完全的.假设在某个平台上,我们有:

// stdint.h
typedef unsigned short uint32_t;

在C/C++中执行算术运算的规则是,如果类型(例如short)比类型更窄int,那么int如果所有值都适合,则它会变宽,unsigned int否则.

假设编译器定义short为32位(带符号)和int48位(带符号).然后这些代码行:

uint32_t a = (...);
uint32_t b = a << …

我有一个int x。为简单起见，假设ints 占据范围 -2^31 到 2^31-1。我想计算2*x-1. 我允许x为任何值 0 <= x<= 2^30。如果我计算 2*(2^30)，我会得到 2^31，这是整数溢出。

一种解决方案是计算2*(x-1)+1. 比我想要的多了一项减法，但这不应该溢出。但是，编译器会将其优化为2*x-1. 这是源代码的问题吗？这是可执行文件的问题吗？

这是 Godbolt 的输出2*x-1：

func(int):                               # @func(int)
        lea     eax, [rdi + rdi]
        dec     eax
        ret

这是 Godbolt 的输出2*(x-1)+1：

func(int):                               # @func(int)
        lea     eax, [rdi + rdi]
        dec     eax
        ret

在我们声明的Java中

short number=1024*1024*1024; 

它会给出编译时错误但是

short number=1024 * 1024 * 1024 * 1024;

编译好.为什么会这样？

以下Python 3.x整数乘法平均在1.66s和1.77s之间:

import time
start_time = time.time()
num = 0
for x in range(0, 10000000):
    # num += 2 * (x * x)
    num += 2 * x * x
print("--- %s seconds ---" % (time.time() - start_time))

如果我更换2 * x * x用2 *(x * x),它需要之间2.04和2.25.怎么会？

另一方面,它与Java相反:2 * (x * x)Java更快.Java测试链接:为什么2*(i*i)比Java中的2*i*i更快？

我运行了每个版本的程序10次,这里是结果.

   2 * x * x        |   2 * (x * x)
---------------------------------------
1.7717654705047607  | 2.0789272785186768
1.735931396484375   | …