64位整数的8位

Question

我想实现64位整数的逐位循环移位。

ROT(a,b)将在i位置移动位以定位i+b。(a是64位整数)

然而，我的avr处理器是一个8位处理器.因此，要表达a，我必须使用unit8_t x[8]。

• x[0]是a中最重要的8位。
• x[7]是a中最不重要的8位。

有谁能帮助实现ROT(a,b)的数组x？

谢谢

Answer 1

如果底层处理器是64位、8位或1位，那么功能就没有什么不同了.如果编译器是兼容的，那么您就可以使用了。使用uint64_t。代码不需要“使用unit8_t”，因为处理器是8位处理器。

uint64_t RPT(uint64_t a, unsigned b) {
  return (a << (b & 63))  |  (a >> ((64 - b) & 63));
}

加了额外的()以表示明示。

& 63 (或者说%64就是你喜欢的那种风格)是为了确保只有6 LSBits of b为这一转变做贡献。任何更高的位仅仅意味着一个循环移位的多次“革命”。

((64 - b) & 63)可以简化为(-b & 63)。

--

但是，如果OP仍然希望“根据数组ROT(a,b)实现unit8_t x[8]"：

#include <stdint.h>

// circular left shift.  MSByte in a[0].
void ROT(uint8_t *a, unsigned b) {
  uint8_t dest[8];
  b &= 63;

  // byte shift
  unsigned byte_shift = b / 8;
  for (unsigned i = 0; i < 8; i++) {
    dest[i] = a[(i + byte_shift) & 7];
  }

  b &= 7; // b %= 8;  form bit shift;
  unsigned acc = dest[0] << b;
  for (unsigned i = 8; i-- > 0;) {
    acc >>= 8;
    acc |= (unsigned) dest[i] << b;
    a[i] = (uint8_t) acc;
  }
}

@vlad_tepesch提出了一种强调AVR 8位本质的解决方案.这是一次未经测试的尝试。

void ROT(uint8_t *a, uint8_t b) {
  uint8_t dest[8];
  b &= 63;  // Could be eliminated as following code only uses the 6 LSBits.

  // byte shift
  uint8_t byte_shift = b / 8u;
  for (uint8_t i = 0; i < 8u; i++) {
    dest[i] = a[(i + byte_shift) & 7u];
  }

  b &= 7u; // b %= 8u;  form bit shift;
  uint16_t acc = dest[0] << b;
  for (unsigned i = 8u; i-- > 0;) {
    acc >>= 8u;
    acc |= (uint8_t) dest[i] << b;
    a[i] = (uint8_t) acc;
  }
}

Answer 2

为什么不把工作留给编译器，只实现一个函数？

uint64_t rotL(uint64_t v, uint8_t r){
  return  (v>>(64-r)) | (v<<r)
}

Answer 3

我认为x(i)是8位。左转n次X(i，j)，其中i是索引数组x(0) -> x(7)，j是元素内的位位置

然后这个位将在Y(( i+n) /8，(i+n)&7)中结束，这将处理高达63的旋转，任何数> 63，您只需修改它。