dscerutti's questions

Tenho vários métodos para acumular quantidades em números de precisão fixa com base no seguinte tipo de dados:

int95_t {
  long long int x;
  int y;
};

Os números são contados para frente xaté que possam ficar fora dos limites e retornar, momento em que yacumulam +1 para estouro e -1 para subfluxo. (Eu também tenho métodos para adicionar números de ponto flutuante, o que pode causar vários estouros ou subfluxos de xe, portanto, acumular várias vezes em y).

Os métodos para adicionar ou subtrair neste tipo de dados são um tanto complexos.

int95_t sum(const int95_t a, const int95_t b) {
  int95_t result = { a.x + b.x, a.y + b.y };
  result.y += (1 - (2 * (b.x < 0LL))) * ((a.x ^ result.x) < 0 && (a.x ^ b.x) >= 0LL) * 2;
  return result;
}

int95_t subtract(const int95_t a, const int95_t b) {
  const int95_t neg_b = { -b.x, -b.y + (2 * (b.x == LLONG_MIN)) };
  return sum(a, neg_b);
}

Sobrecarreguei os operadores +, -, +=, e -=para esse tipo de dado, mas isso não ajuda a limpar meu código tanto assim e pelo seguinte motivo: em muitos contextos, armazenarei não uma matriz de int95_tvalores, mas duas matrizes separadas de valores long long inte int. (O motivo é que há muitas condições sob as quais o acumulador supernário ypode ser ignorado com segurança, e eu quero conservar a largura de banda da memória.) Assim, tenho muitas situações em que, para adicionar um int95_t a outro nessas circunstâncias, parece que ainda preciso fazer:

long long int primary[8];
int secondary[8];
int95_t add_this = { 81573835283, 3816 };

for (int i = 0; i < 8; i++) {
  int95_t tmp = { primary[i], secondary[i] };
  tmp += add_this;
  primary[i] = tmp.x;
  secondary[i] = tmp.y;
}

Existe alguma maneira melhor? Eu esperaria poder contar com qualquer compilador C++ para interpretar corretamente algo assim no caso acima, mas não tenho certeza:

for (int i = 0; i < 8; i++) {
  { primary[i], secondary[i] } += add_this;
}

Obrigado por qualquer ajuda que vocês possam oferecer.

Tenho uma situação em que preciso agrupar 16 bits em um número de 64 bits e depois lê-los como um número inteiro assinado no intervalo [ -32768, 32768 ). O método que escolhi para isso é calcular o número como um int assinado de 16 bits, convertê-lo imediatamente em um int não assinado de 16 bits e, em seguida, fazer o upcast para um int não assinado de 64 bits antes de executar a mudança de bit adequada para obter os 16 bits críticos no lugar apropriado.

Aqui está o pseudocódigo para criar o arranjo compactado de bits:

Given int x, y such that x - y >= -32768 and y - x < 32768;
const int MASK_POS = 45;
const unsigned short int u_s = x - y;
unsigned long long int ull_s = u_s;
ull_s <<= MASK_POS;

Aqui está o pseudocódigo para extrair a diferença nos números originais:

Given unsigned long long int ull_s with 16 bits encoding a signed integer in the 46th through 61st bits;
const unsigned short int u_s = ((ulls >> MASK_POS) & 0xffff);
const short int s_s = u_s;
const int difference_x_and_y = s_s;

Esta me parece uma maneira razoável de empacotar um número inteiro assinado e extraí-lo. Desconfio do comportamento específico da plataforma ao realizar mudanças de bits em números inteiros negativos, mas acho que converter para a forma não assinada do mesmo número de bits antes de atualizar o número de bits gerais no número e, ao contrário, extrair o não assinado inteiro com comprimento de bit desejado antes de converter para um inteiro com sinal de tamanho igual, será seguro.

(Caso alguém esteja curioso, haverá MUITO coisa acontecendo nos outros 48 bits desse número inteiro não assinado de 64 bits em que o material acaba - dos três bits mais altos aos 31 mais baixos e aos 14 do meio, tudo foi analisado. Certamente posso escrever alguns testes de unidade para garantir que esse comportamento se mantenha em qualquer arquitetura, mas se alguém puder ver uma falha agora, é melhor saber com antecedência. Obrigado!)