Batendo o cavalo morto aqui. Uma maneira típica (e rápida) de fazer poderes inteiros em C é este clássico:

int64_t ipow(int64_t base, int exp){
  int64_t result = 1;
  while(exp){
    if(exp & 1)
      result *= base;
    exp >>= 1;
    base *= base;
  }
  return result;
}

No entanto, eu precisava de um poder inteiro de compilação de tempo, então fui em frente e fiz uma implementação recursiva usando constexpr:

constexpr int64_t ipow_(int base, int exp){
  return exp > 1 ? ipow_(base, (exp>>1) + (exp&1)) * ipow_(base, exp>>1) : base;
}
constexpr int64_t ipow(int base, int exp){
  return exp < 1 ? 1 : ipow_(base, exp);
}

A segunda função é apenas para lidar com expoentes menores que 1 de uma maneira previsível. Passagemexp<0 é um erro neste caso.

A versão recursiva é 4 vezes mais lenta

Eu gero um vetor de 10E6 bases de valor aleatório e expoentes no intervalo [0,15] e tempo ambos os algoritmos no vetor (depois de fazer uma corrida sem tempo para tentar remover todos os efeitos de cache). Sem otimização, o método recursice é duas vezes mais rápido que o loop. Mas com -O3 (GCC) o loop é 4 vezes mais rápido que o método recursice.

Minha pergunta para vocês é esta: Alguém pode chegar a uma função ipow () mais rápida que manipule expoente e bases de 0 e possa ser usada como umconstexpr?

(Isenção de responsabilidade: eu nãoprecisar um ipow mais rápido, estou interessado apenas em ver o que as pessoas inteligentes daqui podem criar).