Programacion.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Hola Hola Hola \n",
    "\n",
    "## 5. Realice una función en Python que permita obtener la raíz de una ecuación no lineal de una variable usando el método de \n",
    "#la Secante. La función debe recibir como parámetros la función objetivo f(x), los puntos iniciales, las tolerancias en X y Y, y\n",
    "#debe retornar un arreglo con los valores estimados de la raíz para cada iteración.\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1\n",
    "def f2(x):\n",
    "    return (np.sin(4*x)*x)+(x**5)+(6*x)-4\n",
    "\n",
    "x1 = 0.5\n",
    "x0 = 0.95\n",
    "\n",
    "def sec(f1,x1,x0,Tolx,Toly):\n",
    "    x2pre = 0.0\n",
    "    x2array = []\n",
    "    iter = 0\n",
    "    while 1:\n",
    "        x2 = x1-(f1(x1)*(x0-x1)/(f1(x0)-f1(x1)))\n",
    "        if np.abs(x2-x2pre) <= Tolx:\n",
    "            break\n",
    "        if np.abs(f1(x2))<=Toly:\n",
    "            break    \n",
    "        else:\n",
    "            x0=x1\n",
    "            x1=x2\n",
    "        iter += 1\n",
    "        x2pre = x2\n",
    "        x2array= np.append(x2array,x2)\n",
    "    return x2array,iter,x2\n",
    "\n",
    "print('Numero de iteraciones= ',sec(f2,x1,x0,Tolx,Toly)[1])\n",
    "print('Raiz = ', sec(f2,x1,x0,Tolx,Toly)[2])\n",
    "print('Arreglo valores para cada iteración: ',sec(f2,x1,x0,Tolx,Toly)[0])\n",
    "print('f2(x2)= ',f2(sec(f2,x1,x0,Tolx,Toly)[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 4. Realice una función en Python que permita obtener la raíz de una ecuación no lineal de una variable usando el método del\n",
    "#Newton. La función debe recibir como parámetros la función objetivo f(x), el punto inicial, las tolerancias en X y Y, y debe\n",
    "#retornar un arreglo con los valores estimados de la raíz para cada iteración.\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1\n",
    "def df1(x):\n",
    "    return 10*-x*np.exp(-5*(x**2))-((3/4)*x**(-1/4))+(4*np.cos(4*x))\n",
    "def f2(x):\n",
    "    return (np.sin(4*x)*x)+(x**5)+(6*x)-4\n",
    "def df2(x):\n",
    "    return np.sin(4*x)+(4*x*np.cos(4*x))+(5*x**4)+6\n",
    "def f3(x):\n",
    "    return (-3.65*np.log(x/5.33))+(np.sqrt(2)*np.exp(-6.7174))+(10.54*np.cos(x-2.2))-10.4772\n",
    "def df3(x):\n",
    "    return (-3.65/x)-(np.sin(x-2.2)*10.54)\n",
    "\n",
    "x1 = 0.01\n",
    "x0 = 0.01\n",
    "\n",
    "def new(f1,df1,x0,x1,Tolx,Toly):\n",
    "    x2pre = 0.0\n",
    "    x2array = []\n",
    "    iter = 0\n",
    "    while 1:\n",
    "        x2 = x1-(f1(x1)/df1(x1))\n",
    "        if np.abs(x2-x2pre) <= Tolx:\n",
    "            break\n",
    "        if np.abs(f1(x2))<=Toly:\n",
    "            break\n",
    "        else:\n",
    "            x0=x1\n",
    "            x1=x2\n",
    "        iter += 1\n",
    "        x2pre = x2\n",
    "        x2array= np.append(x2array,x2)\n",
    "    return x2array,iter,x2\n",
    "\n",
    "print('Numero de iteraciones= ',new(f3,df3,x0,x1,Tolx,Toly)[1])\n",
    "print('Raiz =', new(f3,df3,x0,x1,Tolx,Toly)[2])\n",
    "print('Arreglo de valores para cada iteración: ',new(f3,df3,x0,x1,Tolx,Toly)[0])\n",
    "print('f1(x2)= ',f3(new(f3,df3,x0,x1,Tolx,Toly)[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 3. Realice una función en Python que permita obtener la raíz de una ecuación no lineal de una variable usando el método del\n",
    "#punto fijo. La función debe recibir como parámetros la función objetivo f(x), la función g(x), el punto inicial, las tolerancias\n",
    "#en X y Y, y debe retornar un arreglo con los valores estimados de la raíz para cada iteración.\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1\n",
    "def g1(x):\n",
    "    return (np.exp(-5*(x**2))+np.sin(4*x)-1)**(4/3)\n",
    "def g2(x):\n",
    "    return (np.arcsin(-np.exp(-5*(x**2))+x**(3/4)+1))/4\n",
    "def g3(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1+x\n",
    "\n",
    "x1 = 0.25\n",
    "\n",
    "def PF(f,g,x1,Tolx,Toly):\n",
    "    x2 = g(x1)\n",
    "    x2array = []\n",
    "    iter = 0\n",
    "    while 1:\n",
    "        if np.abs(x2-x1) <= Tolx:\n",
    "            break\n",
    "        if np.abs(f(x2))<=Toly:\n",
    "            break\n",
    "        x1 = x2\n",
    "        x2 = g(x1)\n",
    "        iter += 1\n",
    "        x2array= np.append(x2array,x2)\n",
    "    return x2array,iter,x2\n",
    "\n",
    "H = PF(f1,g2,x1,Tolx,Toly)\n",
    "print('Numero de iteraciones= ',H[1])\n",
    "print('Raiz =', H[2])\n",
    "print('Arreglo de valores para cada iteración: ',H[0])\n",
    "print('f1(x2)= ',f1(H[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 2. Realice una función en Python que permita obtener la raíz de una ecuación no lineal de una variable usando el método de\n",
    "#la falsa posición. La función debe recibir como parámetros la función objetivo f(x), el intervalo inicial, las tolerancias en X\n",
    "#y Y, y debe retornar un arreglo con los valores estimados de la raíz para cada iteración.\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1    \n",
    "def f2(x):\n",
    "    return (np.sin(4*x)*x)+(x**5)+(6*x)-4\n",
    "def f3(x):\n",
    "    return (-3.65*np.log(x/5.33))+(np.sqrt(2)*np.exp(-6.7174))+(10.54*np.cos(x-2.2))-10.4772\n",
    "\n",
    "x1 = 0.01\n",
    "x0 = 0.1\n",
    "\n",
    "def FP(f1,x0,x1,Tolx,Toly):\n",
    "    x2pre = 0.0\n",
    "    x2array = []\n",
    "    iter = 0\n",
    "    while 1:\n",
    "        x2 = x1 - (f1(x1)*(x0-x1)/(f1(x0)-f1(x1)))\n",
    "        if np.abs(x2-x2pre) <= Tolx:\n",
    "            break\n",
    "        if np.abs(f1(x2))<=Toly:\n",
    "            break\n",
    "        else:\n",
    "            x0=x1\n",
    "            x1=x2\n",
    "        iter += 1\n",
    "        x2pre = x2\n",
    "        x2array= np.append(x2array,x2)\n",
    "    return x2array,iter,x2\n",
    "    \n",
    "print('Numero de iteraciones= ',FP(f3,x0,x1,Tolx,Toly)[1])\n",
    "print('Raiz =', FP(f3,x0,x1,Tolx,Toly)[2])\n",
    "print('Arreglo de valores para cada iteración: ',FP(f3,x0,x1,Tolx,Toly)[0])\n",
    "print('f1(x2)= ',f3(FP(f3,x0,x1,Tolx,Toly)[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 1. Realice una función en Python que permita obtener la raíz de una ecuación no lineal de una variable usando el método de\n",
    "#la bisección. La función debe recibir como parámetros la función objetivo f(x), el intervalo inicial, las tolerancias en X y Y,\n",
    "#y debe retornar un arreglo con los valores estimados de la raíz para cada iteración.\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1\n",
    "def f2(x):\n",
    "    return (np.sin(4*x)*x)+(x**5)+(6*x)-4\n",
    "def f3(x):\n",
    "    return (-3.65*np.log(x/5.33))+(np.sqrt(2)*np.exp(-6.7174))+(10.54*np.cos(x-2.2))-10.4772\n",
    "\n",
    "x1 = 0.01\n",
    "x0 = 0.1\n",
    "\n",
    "def bisec(f1,x0,x1,Tolx,Toly):\n",
    "    x2pre = 0.0\n",
    "    x2array = []\n",
    "    iter = 0\n",
    "    while 1:\n",
    "        x2 = (x1+x0)/2\n",
    "        if np.abs(x2-x2pre) <= Tolx:\n",
    "            break\n",
    "        if np.abs(f1(x2))<=Toly:\n",
    "            break\n",
    "        if f1(x1)<0 and f1(x2)<0 or f1(x1)>0 and f1(x2)>0:\n",
    "            x1=x2\n",
    "        else:\n",
    "            x0=x2\n",
    "        iter += 1\n",
    "        x2pre = x2\n",
    "        x2array= np.append(x2array,x2)\n",
    "    return x2array,iter,x2\n",
    "\n",
    "print('Numero de iteraciones= ',bisec(f3,x0,x1,Tolx,Toly)[1])\n",
    "print('Raiz =', bisec(f3,x0,x1,Tolx,Toly)[2])\n",
    "print('Arreglo de valores para cada iteración: ',bisec(f3,x0,x1,Tolx,Toly)[0])\n",
    "print('f3(x2)= ',f3(bisec(f3,x0,x1,Tolx,Toly)[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##6. Realice una función en Python que permita calcular la tasa de convergencia de un método dado. La función debe recibir\n",
    "#como parámetros un arreglo con los valores estimados de la raíz para cada iteración y retornar los valores estimados de la\n",
    "#tasa de convergencia para las iteraciones de la 2 hasta la última menos 1.\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-10\n",
    "Toly = 10.0**-10\n",
    "\n",
    "def f1(x):\n",
    "    return np.exp(-5*(x**2))-x**(3/4)+np.sin(4*x)-1\n",
    "\n",
    "x1 = 0.25\n",
    "x0 = 0.35\n",
    "\n",
    "X = bisec(f1,x0,x1,Tolx,Toly)[0]\n",
    "Y = sec(f1,x1,x0,Tolx,Toly)[0]\n",
    "def convergencia(X):\n",
    "    R = []\n",
    "    for i in range(1,np.size(X,0)-1):\n",
    "        r = np.log(X[i+1]/X[i])/np.log(X[i]/X[i-1])\n",
    "        R = np.append(R,r)\n",
    "    return R\n",
    "\n",
    "print(convergencia(X))\n",
    "print(convergencia(Y))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 8.\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(1,1.5,0.001)\n",
    "def f(x):\n",
    "    return (-1.44/(x**(2)))+(0.71/x)+(0.0636*x)+0.088\n",
    "def fi(x):\n",
    "    return (((1/1.44)*((0.71/x)+(0.0636*x)+0.088))**(-1/2))-x\n",
    "def fii(x):\n",
    "    return ((1/0.0636)*((1.44/(x**2))-(0.71/x)-0.088))-x\n",
    "def fiii(x):\n",
    "    return (1.44/(x**2))-(0.71/x)-(0.0636*x)-0.088\n",
    "\n",
    "plt.plot(x,fii(x))\n",
    "plt.plot(x,f(x))\n",
    "plt.plot(x,fiii(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "\n",
    "Tolx = 10.0**-5\n",
    "Toly = 10.0**-5\n",
    "\n",
    "x1 = 2\n",
    "x0 = 2\n",
    "\n",
    "def f(x):\n",
    "    return (-1.44/(x**(2)))+(0.71/x)+(0.0636*x)+0.088\n",
    "def fi(x):\n",
    "    return (((1/1.44)*((0.71/x)+(0.0636*x)+0.088))**(-1/2))\n",
    "def fii(x):\n",
    "    return ((1/0.0636)*((1.44/(x**2))-(0.71/x)-0.088))\n",
    "def fiii(x):\n",
    "    return (1.44/(x**2))-(0.71/x)-(0.0636*x)-0.088+x\n",
    "\n",
    "N = PF(f,fii,x1,Tolx,Toly)\n",
    "print('Numero de iteraciones= ',N[1])\n",
    "print('Raiz =', N[2])\n",
    "print('Arreglo de valores para cada iteración: ',N[0])\n",
    "print('f(n)= ',f1(N[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def fi(x):\n",
    "    return (((1/1.44)*((0.71/x)+(0.0636*x)+0.088))**(-1/2))\n",
    "def fii(x):\n",
    "    return ((1/0.0636)*((1.44/(x**2))-(0.71/x)-0.088))-x\n",
    "def fiii(x):\n",
    "    return (1.44/(x**2))-(0.71/x)-(0.0636*x)-0.088\n",
    "\n",
    "print(fi(1.47298226))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}