<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <h1>Intento de algoritmo de bisección</h1>
Step1:  <h1>Intento de algoritmo de regla falsa</h1>
Step2:  <h1>(testing) Intento de algoritmo de Newton - Raphson (en x^10 -1)</h1>
Step3:  <h1>Intento de algoritmo de secante (en x^10 -1)</h1>
Step4:  <h1>Intento de algoritmo de Newton - Raphson (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -1</h1>
Step5:  <h1>Intento de algoritmo de Newton - Raphson (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -3</h1>
Step6:  <h1>Intento de algoritmo de secante (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -1</h1>
Step7:  <h1>Intento de algoritmo de secante (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -3</h1>
<ASSISTANT_TASK:>
Python Code:
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def biseccion(intA, intB, errorA, noMaxIter):
        if(funcion(intA)*funcion(intB)<0):
            noIter = 0
            errorTmp = 1
            intTmp = 0
            oldInt = intA
            while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
                
                intTmp = (intB+intA)/2
                if(funcion(intA)*funcion(intTmp)<0):
                    intB = intTmp
                else:
                    intA = intTmp
                noIter+=1
                errorTmp=abs((intTmp-oldInt)/intTmp)*100
                oldInt = intTmp
                #print('Error: ',errorTmp)
            print('La raíz es: ',intTmp)
            print('F(raiz) es:' ,funcion(intTmp))
            print('Error: ',errorTmp)
            print('No. de iteraciones realizadas: ',noIter)
        else:
            print('En el intervalo dado la función no presenta cambio de signo')
            print('No hay raices que encontrar')
            
biseccion(-1,0,math.pow(10,-7),1000)
Explanation: <h1>Intento de algoritmo de bisección</h1>
End of explanation
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def reglaFalsa(intA, intB, errorA, noMaxIter):
        if(funcion(intA)*funcion(intB)<0):
            noIter = 0
            errorTmp = 1
            intTmp = 0
            oldInt = intA
            while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
                intTmp = intB-((funcion(intB)*(intA+intB))/(funcion(intA)-funcion(intB)))
                if(funcion(intA)*funcion(intTmp)<0):
                    intB = intTmp
                else:
                    intA = intTmp
                noIter+=1
                errorTmp=abs((intTmp-oldInt)/intTmp)*100
                oldInt = intTmp
                #print('Error: ',errorTmp)
            print('La raíz es: ',intTmp)
            print('F(raiz) es:' ,funcion(intTmp))
            print('Error: ',errorTmp)
            print('No. de iteraciones realizadas: ',noIter)
        else:
            print('En el intervalo dado la función no presenta cambio de signo')
            print('No hay raices que encontrar')
            
reglaFalsa(-1,0,math.pow(10,-6),1000)
Explanation: <h1>Intento de algoritmo de regla falsa</h1>
End of explanation
import math
def funcion(x):
    return math.pow(x,10)-1
def funcionDeriv(x):
    return 10*math.pow(x,9)
def niuton(valorIn, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    oldInt = valorIn
    while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
        intTmp = oldInt-((funcion(oldInt))/(funcionDeriv(oldInt)))
        errorTmp=abs((intTmp-oldInt)/intTmp)*100
        print('Noiter: ',noIter,' oldval:',oldInt,' error:',errorTmp)
        oldInt = intTmp
        noIter+=1
    print('La raíz es: ',intTmp)
    print('F(raiz) es:' ,funcion(intTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niuton(0.5,math.pow(10,-10),1000)
Explanation: <h1>(testing) Intento de algoritmo de Newton - Raphson (en x^10 -1)</h1>
End of explanation
import math
def funcion(x):
    return math.pow(x,10)-1
def niutonConSecante(primerVal, segundoVal, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    while(noIter<noMaxIter and errorTmp>errorA and funcion(segundoVal)!=0):
        valTmp = segundoVal-((funcion(segundoVal)*(primerVal-segundoVal))/(funcion(primerVal)-funcion(segundoVal)))
        primerVal = segundoVal
        segundoVal = valTmp
        errorTmp=abs((segundoVal-primerVal)/segundoVal)*100
        print('Noiter: ',noIter, ' primVal:', primerVal,' segunVal:',segundoVal,' error:',errorTmp)
        noIter+=1
    print('La raíz es: ',valTmp)
    print('F(raiz) es:' ,funcion(valTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niutonConSecante(0.5,-0.9990234375,math.pow(10,-10),1000)
Explanation: <h1>Intento de algoritmo de secante (en x^10 -1)</h1>
End of explanation
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def funcionDeriv(x):
    return (6*math.pow(math.e,6*x))-(8.316*math.pow(math.e,4*x))+(2.88*math.pow(math.e,2*x))
def niuton(valorIn, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    oldInt = valorIn
    while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
        intTmp = oldInt-((funcion(oldInt))/(funcionDeriv(oldInt)))
        errorTmp=abs((intTmp-oldInt)/intTmp)*100
        print('Noiter: ',noIter,' oldval:',oldInt,' error:',errorTmp)
        oldInt = intTmp
        noIter+=1
    print('La raíz es: ',intTmp)
    print('F(raiz) es:' ,funcion(intTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niuton(-1, math.pow(10,-10),1000)
Explanation: <h1>Intento de algoritmo de Newton - Raphson (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -1</h1>
End of explanation
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def funcionDeriv(x):
    return (6*math.pow(math.e,6*x))-(8.316*math.pow(math.e,4*x))+(2.88*math.pow(math.e,2*x))
def niuton(valorIn, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    oldInt = valorIn
    while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
        intTmp = oldInt-((funcion(oldInt))/(funcionDeriv(oldInt)))
        errorTmp=abs((intTmp-oldInt)/intTmp)*100
        print('Noiter: ',noIter,' oldval:',oldInt,' error:',errorTmp)
        oldInt = intTmp
        noIter+=1
    print('La raíz es: ',intTmp)
    print('F(raiz) es:' ,funcion(intTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niuton(-3, math.pow(10,-10),1000)
Explanation: <h1>Intento de algoritmo de Newton - Raphson (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -3</h1>
End of explanation
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def niutonConSecante(primerVal, segundoVal, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    while(noIter<noMaxIter and errorTmp>errorA and funcion(segundoVal)!=0):
        valTmp = segundoVal-((funcion(segundoVal)*(primerVal-segundoVal))/(funcion(primerVal)-funcion(segundoVal)))
        primerVal = segundoVal
        segundoVal = valTmp
        errorTmp=abs((segundoVal-primerVal)/segundoVal)*100
        print('Noiter: ',noIter, ' primVal:', primerVal,' segunVal:',segundoVal,' error:',errorTmp)
        noIter+=1
    print('La raíz es: ',valTmp)
    print('F(raiz) es:' ,funcion(valTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niutonConSecante(-3,-1,math.pow(10,-6),100000)
Explanation: <h1>Intento de algoritmo de secante (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -1</h1>
End of explanation
import math
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def niutonConSecante(primerVal, segundoVal, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    while(noIter<noMaxIter and errorTmp>errorA and funcion(segundoVal)!=0):
        valTmp = segundoVal-((funcion(segundoVal)*(primerVal-segundoVal))/(funcion(primerVal)-funcion(segundoVal)))
        primerVal = segundoVal
        segundoVal = valTmp
        errorTmp=abs((segundoVal-primerVal)/segundoVal)*100
        #print('Noiter: ',noIter, ' primVal:', primerVal,' segunVal:',segundoVal,' error:',errorTmp)
        noIter+=1
    print('La raíz es: ',valTmp)
    print('F(raiz) es:' ,funcion(valTmp))
    print('Error: ',errorTmp)
    print('No. de iteraciones realizadas: ',noIter)
            
niutonConSecante(-3,-0.32944335545310327,math.pow(10,-10),1000)
def funcion(x):
    return math.pow(x,10)-1
funcion(0.5)
def funcion(x):
    return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
funcion(-1)
math.pow(math.e,-1)-1
%matplotlib notebook
import matplotlib.pyplot as plt
import numpy as np
import math
def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))
fig = plt.figure()
ax = fig.add_subplot(111)
ax.spines['left'].set_position('zero')
# ax.spines['right'].set_color('none')
ax.spines['bottom'].set_position('zero')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
x = np.linspace(-10,10,30000)
plt.plot(x, np.exp(x))
y = [funcion(punto) for punto in x]
plt.plot(x, y)
import math
def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))
a = -4
b = -2
max = 1000
epsilon = 0
iter = 0
xold = b
while iter<=max:
    x = a-((funcion(a)*(b-a))/(funcion(b)-funcion(a)))
    iter += 1
    if abs(x-xold)<epsilon*abs(x):
        print("ajá",x)
    else:
        print(iter,a,b,x)
        xold = x
        if funcion(a)*funcion(x) > 0:
            a = x
        else:
            b = x
import math
def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))
def funcionDeriv(x):
    return (5*(math.exp((x/2)+1))*(math.sin(x+3)+(2*math.cos(x+3))))
def newtonRaphson(val, errorA, noMaxIter):
    noIter = 0
    errorTmp = 1
    intTmp = 0
    while(noIter<noMaxIter):
        valTmp = val-((funcion(val))/(funcionDeriv(val)))
        if abs(valTmp-val) < errorA:
            print('es >:V : ',valTmp)
            break
        val = valTmp
        noIter+=1
newtonRaphson(-5, math.pow(10,-15),10000)
newtonRaphson(0, math.pow(10,-15),10000)
import math
import numpy as np
def cuadratica(r,s):
    discrim = math.pow(r,2)+(4*s)
    raices = []
    if discrim > 0: #raiz real
        raices.append((r+math.sqrt(discrim))/(2))
        raices.append((r-math.sqrt(discrim))/(2))
    else: #raiz compleja
        raices.append(str(r/2)+'+'+str(math.sqrt(abs(discrim))/2))
        raices.append(str(r/2)+'-'+str(math.sqrt(abs(discrim))/2))
    return raices
def generateb(a, r, s):
    b = []
    b.append(a[0])
    b.append(a[1]+(r*b[-1]))
    for i in a[2:]:
        b.append(i+(r*b[-1])+(s*b[-2]))
    return b
def generatec(b, r, s):
    c = []
    c.append(b[0])
    c.append(b[1]+(r*c[-1]))
    for i in b[2:-1]:
        c.append(i+(r*c[-1])+(s*c[-2]))
    return c
r = 0
s = 0
a = [1,-5,10,-10,4] #a4, a3, a2, a1, a0
grado = len(a)
errorA = 0.000001
noMaxIter = 1000
listaRaices = []
rerror = 100
serror = 100
noIter = 1
while len(listaRaices) < len(a):
    print('=-='+str(len(listaRaices)))
    while rerror>errorA or serror>errorA:
        b = generateb(a,r,s) #b4, b3, b2, b1, b0 ...
        c = generatec(b,r,s) #c4, c3, c2, c1
        eq1 = np.array([[c[-2],c[-3]],[c[-1],c[-2]]])
        eq2 = np.array([-b[-2],-b[-1]])
        solEq = np.linalg.solve(eq1,eq2)
        rdelta = solEq[0]
        sdelta = solEq[1]
        r += rdelta
        s += sdelta
        rerror = abs(rdelta/r)*100
        serror = abs(sdelta/s)*100
        noIter+=1
    listaRaices.extend(cuadratica(r,s))
    b = b[:-2]
    if len(a)-len(listaRaices) == 2:
        listaRaices.extend(cuadratica(b[0],b[1]))
        print('==2')
    elif len(a)-len(listaRaices) == 1:
        listaRaices.append(-s/r)
        print('==1')
print(noIter)
print(r)
print(s)
print(noIter)
print('---------------')
for i in listaRaices:
    print(i)
Explanation: <h1>Intento de algoritmo de secante (en exp(6x)+1.44 exp(2x)- 2.079 exp(4x)- 0.333) con punto inicial de -3</h1>
End of explanation
<END_TASK>