Programa para Calcular e^x por Recursión (usando Series de Taylor)

El valor de la función exponencial se puede calcular utilizando la serie de Taylor. 

 = 1 + x/1! + /2! + /3! + ...... + until n terms

A medida que aumenta el número de términos se obtiene el valor más preciso de e ^x .

Para encontrar e^x usando la función recursiva, necesitamos usar variables estáticas. Una función puede devolver solo un valor, y cuando necesitamos incluir múltiples valores en una función recursiva, usamos variables estáticas. La serie de Taylor es una combinación de múltiples valores como la suma, la potencia y el término factorial, por lo que usaremos variables estáticas.

Para la potencia de x, usaremos p, y para factoriales, usaremos f como variables estáticas. 

La función que se muestra a continuación se utiliza para aumentar la potencia de x.  

p = p*x 

La siguiente función se utiliza para encontrar factoriales. 

f = f*n

La siguiente función se utiliza para calcular la suma de la serie. 

r+p/f

Donde r es la llamada recursiva a la función.

A continuación se muestra la implementación de la idea anterior.  

// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Recursive Function with static
// variables p and f
double e(int x, int n)
{
    static double p = 1, f = 1;
    double r;
 
    // Termination condition
    if (n == 0)
        return 1;
 
    // Recursive call
    r = e(x, n - 1);
 
    // Update the power of x
    p = p * x;
 
    // Factorial
    f = f * n;
 
    return (r + p / f);
}
 
// Driver code
int main()
{
    int x = 4, n = 15;
    cout<<"\n"<< e(x, n);
 
    return 0;
}
 
// this code is contributed by shivanisinghss2110

// C implementation of the approach
#include <stdio.h>
 
// Recursive Function with static
// variables p and f
double e(int x, int n)
{
    static double p = 1, f = 1;
    double r;
 
    // Termination condition
    if (n == 0)
        return 1;
 
    // Recursive call
    r = e(x, n - 1);
 
    // Update the power of x
    p = p * x;
 
    // Factorial
    f = f * n;
 
    return (r + p / f);
}
 
// Driver code
int main()
{
    int x = 4, n = 15;
    printf("%lf \n", e(x, n));
 
    return 0;
}

// Java implementation of the approach
import java.text.*;
 
class GFG {
 
    // Recursive Function with static
    // variables p and f
    static double p = 1, f = 1;
    static double e(int x, int n)
    {
        double r;
 
        // Termination condition
        if (n == 0)
            return 1;
 
        // Recursive call
        r = e(x, n - 1);
 
        // Update the power of x
        p = p * x;
 
        // Factorial
        f = f * n;
 
        return (r + p / f);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int x = 4, n = 15;
        DecimalFormat df = new DecimalFormat("0.######");
        System.out.println(df.format(e(x, n)));
    }
}
 
// This code is contributed by mits

# Python implementation of the approach
 
# Recursive Function
# global variables p and f
p = 1.0
f = 1.0
 
 
def e(x, n):
 
    global p, f
 
    # Termination condition
    if (n == 0):
        return 1
 
    # Recursive call
    r = e(x, n - 1)
 
    # Update the power of x
    p = p * x
 
    # Factorial
    f = f * n
 
    return (r + p / f)
 
# Driver code
 
 
x = 4
n = 15
print(e(x, n))
 
# This contributed by ihritik

// C# implementation of the approach
using System;
 
class GFG {
 
    // Recursive Function with static
    // variables p and f
    static double p = 1, f = 1;
    static double e(int x, int n)
    {
        double r;
 
        // Termination condition
        if (n == 0)
            return 1;
 
        // Recursive call
        r = e(x, n - 1);
 
        // Update the power of x
        p = p * x;
 
        // Factorial
        f = f * n;
 
        return (r + p / f);
    }
 
    // Driver code
    static void Main()
    {
        int x = 4, n = 15;
        Console.WriteLine(Math.Round(e(x, n), 6));
    }
}
 
// This code is contributed by mits

<script>
 
// Javascript implementation of the approach
 
// Recursive Function with static
// variables p and f
p = 1, f = 1;
function e(x, n)
{
    var r;
 
    // Termination condition
    if (n == 0)
        return 1;
 
    // Recursive call
    r = e(x, n - 1);
 
    // Update the power of x
    p = p * x;
 
    // Factorial
    f = f * n;
 
    return (r + p / f);
}
 
// Driver Code
var x = 4, n = 15;
var res = e(x, n);
 
document.write(res.toFixed(6));
 
// This code is contributed by kirti
 
</script>

54.597883

Complejidad del tiempo: 

Para encontrar esto vamos a determinar la multiplicación total realizada.

e^x = 1 + x/1! +x^2/2! +x^3/3! + …… + hasta n términos

       = 1 + x/1 + x*x/1*2 + x*x*x/1*2*3 + x*x*x*x/1*2*3*4 …… + hasta n términos

           0 0 2 4 8 Número de multiplicaciones en los términos anteriores

Entonces, para n términos, la multiplicación total realizada es comparable a la suma de n números naturales (ya que se forma una serie paralela de números pares).

y sabemos suma de n números naturales = n*(n+1)/2 cuyo orden es n ²

Por lo tanto, la complejidad temporal si este enfoque es O(n ² )

Espacio Auxiliar: 

La llamada recursiva tendrá lugar n+1 veces y, por lo tanto, se crearán n+1 registros de activación como máximo. Eso muestra que la complejidad del espacio es O(n).