Vencer al caballo muerto aquí. Una forma típica (y rápida) de hacer potencias de enteros en C es este clásico:

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;
}

Sin embargo, necesitaba un poder entero de tiempo de compilación, así que seguí adelante e hice una implementación recursiva utilizando 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);
}

La segunda función es solo para manejar los exponentes menores de 1 de una manera predecible. Pasoexp<0 Es un error en este caso.

La versión recursiva es 4 veces más lenta.

Generé un vector de 10E6 bases de valor aleatorio y exponentes en el rango [0,15] y cronometré ambos algoritmos en el vector (después de realizar una ejecución no cronometrada para intentar eliminar cualquier efecto de almacenamiento en caché). Sin optimización, el método recursivo es dos veces más rápido que el bucle. Pero con -O3 (GCC) el bucle es 4 veces más rápido que el método recursivo.

Mi pregunta para ustedes es esta: ¿Puede alguien obtener una función ipow () más rápida que maneje exponentes y bases de 0 y se pueda usar comoconstexpr?

(Descargo de responsabilidad: yo nonecesitar un ipow más rápido, solo me interesa ver qué pueden hacer las personas inteligentes aquí).