标签: integer-arithmetic

我需要实现一个自定义整数算术系统，例如十六进制，但多了 4 个字母。

例如，十六进制用来[0-9,A-F]表示数字。我的会用[0-9,A-J].

Sample representations:  
Decimal(5): Hex(5), MySystem(5)
Decimal(15): Hex(F), MySystem(F)
Decimal(16): Hex(10), MySystem(G)
Decimal(17): Hex(11), MySystem(H)
Decimal(18): Hex(12), MySystem(I)
Decimal(19): Hex(13), MySystem(J)
Decimal(20): Hex(14), MySystem(10)
...

我无法决定是否应该将数字存储为String或 as BigInteger。
如果您能指出我可以阅读十六进制如何在代码中实现的地方，那将会非常有帮助。到目前为止，我只能找到仅用于从/到其他算术系统的转换的实现。

以下代码模仿实际的生产代码.双引号用作来自XML文件的实际数据,使用XML:Twig以下方法解析:

#!/usr/bin/perl

use strict;
use warnings;
use diagnostics;
use Devel::Peek;

my $linetotalinclusive = "8458.80" * 1_000_000;

$linetotalinclusive = $linetotalinclusive;

my $c = "7980.00" * 1_000_000;

my $data = $linetotalinclusive - $c;

print Dump $c;

print Dump $linetotalinclusive;

print "$linetotalinclusive - $c = $data \n";

给出以下结果:

SV = PVNV(0x22885f0) at 0x21984f8
  REFCNT = 1
  FLAGS = (PADMY,IOK,NOK,pIOK,pNOK)
  IV = 7980000000
  NV = 7980000000
  PV = 0
SV = PVNV(0x2288650) at 0x21984c8
  REFCNT = 1
  FLAGS = (PADMY,NOK,pIOK,pNOK)
  IV = …

当我遇到问题时，我正在编写一个函数来计算球体的体积，但我不知道为什么如果将 4/3 * PI 更改为 PI * 4/3 我得到了不同的结果。评估的顺序是什么，如果我使用 (4/3) * PI 和 PI * (4/3) 这样的括号，我在这两种情况下都得到了错误的答案。

#define PI 3.141592

float Volume(int radius){
      return (4/3 * PI * pow(radius, 3));
}

float Volume(int radius){
      return (PI * 4/3 * pow(radius, 3)); //the good one
}

请有人亲切地为我解释这个功能谢谢!

int overflow(int x, int y)
{
   int result, non_overflow, overflow, result_sign, mask;

   result = x + y;
   result_sign = result >> 31;  //Need help starting from here... I know
                                //it is shifting 31 bits... but why??
   non_overflow = ((x ^ y) | ~(y ^ result)) >> 31;
   overflow = ~non_overflow;

   mask = overflow << 31;

   return (non_overflow & result) | (overflow & (result_sign ^ mask));  
}

请看一下这段代码:

#include <stdio.h>
int main(void)
{
short s = -1;

printf("sizeof(short) = %lu\n", sizeof(short));
printf("sizeof(int) = %lu\n", sizeof(int));
printf("sizeof(long) = %lu\n", sizeof(long));
printf("s = %hd\n", s);
printf("s = %d\n", s);
printf("s = %ld\n", s);

return 0;
}  

它给出了输出:

sizeof(short) = 2  
sizeof(int) = 4  
sizeof(long) = 8  
s = -1  
s = -1  
s = 4294967295  

在最后一行,为什么s = 4294967295不是s = -1通过这个问题,我才知道在C中,当变量被提升时,它的值保持不变.

是否有任何无分支或类似的黑客用于将整数钳位到0到25​​5的间隔,或者是一个双倍到0.0到1.0的间隔？(两个范围都是封闭的,即端点是包含的.)

我正在使用明显的最小 - 最大检查:

int value = (value < 0? 0 : value > 255? 255 : value);

但有没有办法让它更快 - 类似于"模"钳value & 255？有没有办法用浮点做类似的事情？

我正在寻找便携式解决方案,所以最好不要使用CPU/GPU特定的东西.

我目前正在研究一个更复杂的程序,我遇到了一个非常奇怪的语法错误,最好用以下最小例子来证明:

#include <iostream>

int main(int argc, char *argv[]){
        char c = 1 + '0';
        std::cout << 1 + '0' << std::endl;
        std::cout << c << std::endl;
        std::cout << '0' + 1 << std::endl;
        return 1;
}

此示例生成以下输出:

$ ./program
49
1
49

这里似乎发生的事情是,当从单个数字整数表达式到字符的转换发生在流语句之外时,它会成功,但是当它在这样的语句中发生时,它会产生垃圾回答.

我试图找到其他人在谷歌上问类似的东西,但我找不到任何相关的东西.

我(Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609在Ubuntu 16.04 LTS x64上使用g ++ ,但问题也出现在clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)中,这排除了编译器错误.

考虑这个代码：

val x1: Byte = 0x00
val x2: Byte = 0x01
val x3: Byte = x1 + x2;

这会产生编译错误，因为添加 2 Bytes的结果是Int.

为了解决这个问题，我需要手动将结果转换回一个字节：

val x3: Byte = (x1 + x2).toByte()

这是非常违反直觉的。为什么算术运算符会这样工作？

我有一个大型uint8_t数组（大小= 1824 * 942）。我想对每个元素执行相同的操作。特别是我需要从每个元素中减去-15。

该阵列每秒刷新20次，因此时间是个问题，我避免在阵列上循环。

是否有捷径可寻？

这是
我正在学习用C语言编程的调试过程的屏幕截图.我试图找出一个数字是否是一个镜像,但程序编译没有错误但没有给出所需的结果.调试程序显示它在while时触发(sqroot!= 0);

    // Mirror number
    #include <stdio.h>
    #include <math.h>
    int main() {
            int num, rev1, rev2, rem1, rem2, sqr, sqroot;
            printf("Enter a number\n");
            scanf("%d", & num);
            sqr = pow(num, 2);
            while (sqr != 0) {
                    rem1 = sqr % 10;
                    rev1 = rev1 * 10 + rem1;
                    sqr = sqr / 10;

            }
            sqroot = sqrt(rev1);

            while (sqroot != 0); {
                    rem2 = sqroot % 10;
                    rev2 = rev2 * 10 + rem2;
                    sqroot = sqroot / …