una - potenciacion de fracciones

¿Cómo se hace la exponenciación en C?

Question

Intenté "x = y ** e", pero eso no funcionó.

Answer 1

La versión no recursiva de la función no es demasiado difícil; aquí está para enteros:

long powi(long x, unsigned n)
{
    long  p;
    long  r;

    p = x;
    r = 1.0;
    while (n > 0)
    {
        if (n % 2 == 1)
            r *= p;
        p *= p;
        n /= 2;
    }

    return(r);
}

(Hackeado el código para elevar un valor doble a una potencia entera; por ejemplo, tuvo que eliminar el código para tratar con recíprocos).

Answer 2

o simplemente podría escribir la función de potencia, con recursión como una bonificación adicional

int power(int x, int y){
      if(y == 0)
        return 1;
     return (x * power(x,y-1) );
    }

sí, sí, sé que esta es una complejidad de espacio y tiempo menos eficiente, pero la recursividad es simplemente más divertida.

Answer 3

pow solo funciona en números de coma flotante ( double s, en realidad). Si quieres tomar potencias de enteros, y no se sabe que la base sea un exponente de 2 , tendrás que hacer tu propia.

Por lo general, la forma tonta es lo suficientemente buena.

int power(int base, unsigned int exp) {
    int i, result = 1;
    for (i = 0; i < exp; i++)
        result *= base;
    return result;
 }

Aquí hay una solución recursiva que toma O(log n) espacio y tiempo en lugar del O(1) espacio O(n) tiempo:

int power(int base, int exp) {
    if (exp == 0)
        return 1;
    else if (exp % 2)
        return base * power(base, exp - 1);
    else {
        int temp = power(base, exp / 2);
        return temp * temp;
    }
}

Answer 4

int power(int x,int y){
 int r=1;
 do{
  r*=r;
  if(y%2)
   r*=x;
 }while(y>>=1);
 return r;
};

(iterativo)

int power(int x,int y){
 return y?(y%2?x:1)*power(x*x,y>>1):1;
};

(si tiene que ser recursivo)

Imo, el algoritmo definitivamente debería ser O (logn)

Answer 5

Similar a una respuesta anterior, manejará las potencias enteras positivas y negativas de una doble muy bien.

double intpow(double a, int b)
{
  double r = 1.0;
  if (b < 0)
  {
    a = 1.0 / a;
    b = -b;
  }
  while (b)
  {
    if (b & 1)
      r *= a;
    a *= a;
    b >>= 1;
  }
  return r;
}

Answer 6

use la función pow (toma float s / double s).

man pow :

   #include <math.h>

   double pow(double x, double y);
   float powf(float x, float y);
   long double powl(long double x, long double y);

EDITAR: Por cierto, para el caso especial de potencias enteras positivas de 2 , puede usar el desplazamiento de bit: (1 << x) será igual a 2 a la potencia x . Hay algunos inconvenientes potenciales con esto, pero en general sería correcto.

Answer 7

así es como - http://algohub.blogspot.com/2014/04/exponentiation.html

es un algoritmo de divide y vencerás ... divide la entrada en partes más pequeñas hasta que se vuelve masticable y la resuelve, y luego usa ese resultado del problema más pequeño para construir incrementalmente la solución para problemas más grandes hasta que hayas resuelto el problema para la entrada dada

es sencillo ... dígame si tiene preguntas

Answer 8

Para agregar a lo que Evan dijo: C no tiene un operador incorporado para la exponenciación, porque no es una operación primitiva para la mayoría de las CPU. Por lo tanto, se implementa como una función de biblioteca.

Además, para calcular la función e ^ x, puede usar las funciones exp(double) , expf(float) y expl(long double) .

Tenga en cuenta que no desea utilizar el operador ^ , que es el operador OR exclusivo en modo bit .