{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# 1 High Dimensional Chains" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}t \\ {\\mapsto}\\ {\\left(t + 1\\right)}^{2} t \\ {\\mapsto}\\ 3 \\, t^{2}$ " ] }, "execution_count": 8, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 8, "metadata": { }, "output_type": "execute_result" } ], "source": [ "# a)\n", "x(t) = (t+1)^2\n", "y(t) = 3*t^2\n", "\n", "show(x, y)\n", "\n", "parametric_plot((x(t), y(t)), (t, 0, 5), \n", " axes_labels=['$x$', '$y$'])" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left( x, y \\right) \\ {\\mapsto} \\ {\\left(x^{2} + y^{2}\\right)} e^{\\left(5 \\, x\\right)}$ " ] }, "execution_count": 9, "metadata": { }, "output_type": "execute_result" } ], "source": [ "T(x,y) = e^(5*x)*(x^2 + y^2)\n", "show(T)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}t \\ {\\mapsto}\\ {\\left({\\left(t + 1\\right)}^{4} + 9 \\, t^{4}\\right)} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)}$ " ] }, "execution_count": 26, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Lowest value of temperature is 148.4132\n" ] } ], "source": [ "x(t) = (t+1)^2\n", "y(t) = 3*t^2\n", "T_t(t) = e^(5*x)*(x^2 + y^2)\n", "show(T_t)\n", "para_plt = parametric_plot3d((T_t,x, y), (t, 0, 5), boundary_style={\"color\": \"black\", \"thickness\": 2})\n", "para_plt\n", "\n", "print 'Lowest value of temperature is %.4f' % T_t(0)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### 1.d) Testing chain rule for T(t)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Partial derivatives of T(t) in terms of x and y\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left( x, y \\right) \\ {\\mapsto} \\ \\left(5 \\, {\\left(x^{2} + y^{2}\\right)} e^{\\left(5 \\, x\\right)} + 2 \\, x e^{\\left(5 \\, x\\right)},\\,2 \\, y e^{\\left(5 \\, x\\right)}\\right)$ " ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "dT/dt with chain rule\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}t \\ {\\mapsto}\\ 36 \\, t^{3} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)} + 2 \\, {\\left(2 \\, {\\left(t + 1\\right)}^{2} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)} + 5 \\, {\\left({\\left(t + 1\\right)}^{4} + 9 \\, t^{4}\\right)} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)}\\right)} {\\left(t + 1\\right)}$ " ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "T(t) in terms of t\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}{\\left({\\left(t + 1\\right)}^{4} + 9 \\, t^{4}\\right)} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)}$ " ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "dT/dt without chain rule\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}t \\ {\\mapsto}\\ 10 \\, {\\left({\\left(t + 1\\right)}^{4} + 9 \\, t^{4}\\right)} {\\left(t + 1\\right)} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)} + 4 \\, {\\left({\\left(t + 1\\right)}^{3} + 9 \\, t^{3}\\right)} e^{\\left(5 \\, {\\left(t + 1\\right)}^{2}\\right)}$ " ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Checking above two equations\n" ] }, { "data": { "text/plain": [ "[t == t]" ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" } ], "source": [ "var('t')\n", "\n", "# Calculating dT/dt with chain rule\n", "T(x, y) = e^(5*x)*(x^2+y^2)\n", "print 'Partial derivatives of T(t) in terms of x and y'\n", "show(T_1.diff())\n", "\n", "dT_dx = T.diff()[0]\n", "dT_dy = T.diff()[1]\n", "print'dT/dt with chain rule'\n", "check_dT_dt = dT_dx((t+1)^2,3*t^2)*dx_dt + dT_dy((t+1)^2,3*t^2)*dy_dt\n", "show(check_dT_dt)\n", "\n", "\n", "# Calculating dT/dt without chain rule\n", "x(t) = (t+1)^2\n", "y(t) = 3*t^2\n", "\n", "# Recreating T(t) in terms of t only.\n", "T(t) = e^(5*x)*(x^2+y^2)\n", "print 'T(t) in terms of t'\n", "show(T(t))\n", "test_dT_dt = T.diff()\n", "print'dT/dt without chain rule'\n", "show(test_dT_dt)\n", "\n", "# Equating those two equations\n", "print 'Checking above two equations'\n", "solve(check_dT_dt - test_dT_dt == 0, t)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# 2. Taking up a notch" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": "\n\n" }, "execution_count": 32, "metadata": { }, "output_type": "execute_result" } ], "source": [ "# Plotting regtion E{(x, y, z)|0 <=z <=2 - x^2/2, 0 <=y <= x}\n", "var('x, y, z')\n", "\n", "region1 = implicit_plot3d(y==x, (x, 0, 2), (y, 0, 2), (z, 0, 2), \n", " plot_points=100, \n", " color = 'red',\n", " legend_label = '$y<=x$',\n", " axes_labels=['$x$','$y$','$z$'],\n", " region=lambda x,y,z: x>=0 and x<=2 and z>= 0 and z<=2-x^2/2)\n", "\n", "region2 = implicit_plot3d(z==2-x^2/2, (x, 0, 2), (y, 0, 2), (z, 0, 2), \n", " plot_points=100, \n", " legend_label = '$z<=2-x^2/2$',\n", " region=lambda x,y,z: y <= x and y >=0 and x>=0 and x<=2)\n", "region1 + region2" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Volume or Triple Integral of f(x, y, z) = 1 over E is 2.00\n", "Mass or Triple Integral of f(x, y, z) = kz over E is 4/3*k\n" ] } ], "source": [ "# triple integral of 1\n", "var('x, y, z')\n", "f(x, y, z) = 1 \n", "# Triple integration over f(x, y, z) = 1 for calculating volme\n", "v = integral(integral(integral(f(x, y ,z), z, 0, 2-x^2/2), y, 0, x), x, 0, 2)\n", "print 'Volume or Triple Integral of f(x, y, z) = 1 over E is %.2f' % v\n", "\n", "# Calculating mass with triple integrals over density function\n", "var('x, y, z')\n", "var('k')\n", "f(x, y, z) = k * z\n", "m = integral(integral(integral(f(x, y, z), z, 0, 2-x^2/2), y, 0, x), x, 0, 2)\n", "print 'Mass or Triple Integral of f(x, y, z) = kz over E is %s' % m" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "M_yz: 128/105*k\n", "M_xz: 64/105*k\n", "M_xy: 4/3*k\n", "The center of mass is: (32/35, 16/35, 1)\n" ] } ], "source": [ "# Calculating Center of mass\n", "var('x, y, z')\n", "var('k')\n", "d(x, y, z) = k*z\n", "\n", "m_yz = integral(integral(integral(x*d, z, 0, 2-x^2/2), y, 0, x), x, 0, 2)\n", "print 'M_yz: %s' % m_yz\n", "\n", "m_xz = integral(integral(integral(y*d, z, 0, 2-x^2/2), y, 0, x), x, 0, 2)\n", "print 'M_xz: %s' % m_xz\n", "\n", "m_xy = integral(integral(integral(z*d, z, 0, 2-x^2/2), y, 0, x), x, 0, 2)\n", "print 'M_xy: %s' % m_xy\n", "\n", "x_center = m_yz/m\n", "y_center = m_xz/m\n", "z_center = m_xy/m\n", "\n", "print 'The center of mass is: (%s, %s, %s)' % (x_center, y_center, z_center)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# 3 Euler Solver" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "For h=3.000000, savings after a year = 3250.27\n", "For h=2.000000, savings after a year = 3266.68\n", "For h=1.000000, savings after a year = 3283.31\n", "For h=0.500000, savings after a year = 3291.71\n", "For h=0.100000, savings after a year = 3326.77\n", "For h=0.010000, savings after a year = 3302.83\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "For h=0.001000, savings after a year = 3300.44\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "For h=0.000500, savings after a year = 3300.16\n" ] } ], "source": [ "# Algorithm for solving estimated value of y\n", "\n", "def savings_estimator(r=0.01, q=250, \n", " n = 12, y0=100, h=1, \n", " t0=0, verbose=False, \n", " return_arr=False):\n", " var('y0, t0, h')\n", "\n", " #y1 = y0 + f(t0, y0)*h\n", " '''\n", " Inputs:\n", " r -> Interest rate (0.01 in question)\n", " q -> savings rate (250$ per month in question)\n", " y0 -> Initial investment (Default y = 100)\n", " t0 -> Initial time (Default t=0)\n", " h -> step size\n", " n -> number of months (Default n=12 or one year)\n", " verbose -> Denotes whether or not to print savings after each\n", " step size\n", " return_arr -> Status to return the arrays storing savings and\n", " time in each increment\n", " Outputs:\n", " - Prints the savings after each increment\n", " - Returns the savings after a year\n", " \n", " '''\n", "\n", " y_s = [y0] # array to store savings after each incresment\n", " t_s = [t0] # array to store time steps\n", " \n", " f(t, y) = r*y + q #dy/dt equation\n", "\n", " i = 1 # index position of array\n", " t_n = t0 # temparay variable to store time steps\n", "\n", " while int(t_n) < n:\n", " #t_n = t_n-1 + h\n", " t_n = t_s[i-1] + h\n", " \n", " #y_n = y_n-1 + f(t_n-1, y_n-1)*h\n", " y_n = y_s[i-1] + f(t_s[i-1], y_s[i-1])*h\n", " y_s.append(y_n)\n", " t_s.append(t_n)\n", "\n", " if verbose:\n", " # Prints savings after each step size\n", " print 'Amount at t=%.2f is %.2f' % (t_s[i], y_s[i])\n", " \n", " i += 1\n", " \n", " if return_arr:\n", " # Returns all the arrays if required\n", " return t_s, y_s\n", " \n", " return y_s[-1]\n", "\n", "# Using following values of step sizes.\n", "h_arr = [1, 2, 3, 0.1, 0.5, 0.01, 0.001, 0.0005]\n", "\n", "h_arr.sort(reverse=True)\n", "\n", "for h in h_arr:\n", " print 'For h=%f, savings after a year = %.2f' % (h, savings_estimator(h=h))" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Step_size: 1.00\n", "Amount at t=1.00 is 351.00\n", "Amount at t=2.00 is 604.51\n", "Amount at t=3.00 is 860.56\n", "Amount at t=4.00 is 1119.16\n", "Amount at t=5.00 is 1380.35\n", "Amount at t=6.00 is 1644.16\n", "Amount at t=7.00 is 1910.60\n", "Amount at t=8.00 is 2179.70\n", "Amount at t=9.00 is 2451.50\n", "Amount at t=10.00 is 2726.02\n", "Amount at t=11.00 is 3003.28\n", "Amount at t=12.00 is 3283.31\n" ] }, { "data": { "image/png": "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" }, "execution_count": 6, "metadata": { }, "output_type": "execute_result" } ], "source": [ "# plot slope field\n", "\n", "r = 0.01 # interest rate\n", "q = 250 # savings rate\n", "\n", "dy_dt = r*y + q\n", "plt_slope = plot_slope_field(dy_dt, (t,0,12), (y,0,3500),\n", " axes_labels=['$t$ (in months)',\n", " '$y$-Savings in dollars'])\n", "\n", "# getting output from savings estimator\n", "step_size = 1\n", "print 'Step_size: %.2f' % step_size\n", "(t_s, y_s) = savings_estimator(h=step_size, verbose=True, return_arr=True)\n", "\n", "# storing the time and savings in each step to points array\n", "points = []\n", "for ind in range(len(t_s)):\n", " points.append([t_s[ind], y_s[ind]])\n", "\n", "plt_point = scatter_plot(points)\n", "\n", "show(plt_slope + plt_point)" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "outputs": [ { "ename": "NotImplementedError", "evalue": "Maxima was unable to solve this ODE. Consider to set option contrib_ode to True.", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0m__tmp__\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"t\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msymbolic_expression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mInteger\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m250\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m# monthly savings rate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0msoln\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdesolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdiff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0;34m'Solution of differential equation is'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/ext/sage/sage-8.4_1804/local/lib/python2.7/site-packages/sage/calculus/desolvers.pyc\u001b[0m in \u001b[0;36mdesolve\u001b[0;34m(de, dvar, ics, ivar, show_method, contrib_ode, algorithm)\u001b[0m\n\u001b[1;32m 595\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Maxima was unable to solve this ODE.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 596\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 597\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Maxima was unable to solve this ODE. Consider to set option contrib_ode to True.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 599\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mshow_method\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNotImplementedError\u001b[0m: Maxima was unable to solve this ODE. Consider to set option contrib_ode to True." ] } ], "source": [ "# Due to memory and implementation issues this code does not run in CoCalc\n", "# Please run it on the local SageMath server of your laptop\n", "t = var('t')\n", "y = function('y')(t)\n", "r = 0.01 # interest rate\n", "q(t) = 250 # monthly savings rate\n", "\n", "soln = desolve(diff(y, t) -r*y - q(t), y)\n", "\n", "print 'Solution of differential equation is'\n", "show(soln)\n", "# Solution appears as (C−25000*e(−t/100))e^(t/100)\n", "\n", "print 'In simpler terms: y(t) is'\n", "var('C')\n", "y_actual(t) = C*e^(t/100) - 25000\n", "show(y_actual(t))\n", "\n", "# Finding value of C using intial values\n", "# y(0) = 100, when t = 0\n", "results = solve(y_actual(0) == 100, C)\n", "C = results[0].rhs()\n", "print 'The value of C is %.2f' % C\n", "\n", "# Redefining the function with value of C\n", "y_actual(t) = C*e^(t/100) - 25000\n", "print 'The actual function y(t) is '\n", "show(y_actual(t))\n", "\n", "print 'Actual savings after a year is: %.4f' % y_actual(12)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# 4 Something fishy" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 88, "metadata": { }, "output_type": "execute_result" } ], "source": [ "# Plotting slope field for dP/dt = rP(1-P/N)\n", "t, P = var('t,P')\n", "N = 100 # max. capacity of 10,000 fish\n", "r = 0.14 # reproductive rate of 14% per week\n", "plt_slope = plot_slope_field(r*P*(1-(P/N)),\n", " (t,0,52),(P,-2,N+2),\n", " axes_labels=['$t$', '$P$']\n", " )\n", "plt_line = plot(N,(x,0,52))\n", "\n", "plt_slope + plt_line" ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 97, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 97, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 97, "metadata": { }, "output_type": "execute_result" } ], "source": [ "t, P, H = var('t,P, H')\n", "\n", "N = 100 # max. capacity of 10,000 fish\n", "r = 0.14 # reproductive rate of 14% per week\n", "plt_slope = plot_slope_field((r*P*(1-(P/N))-H),\n", " (H,0,5), (P,0,N+2),\n", " axes_labels=['$H$', '$P$'])\n", "\n", "plt_slope.show()\n", "\n", "plt_slope = plot_slope_field((r*P*(1-(P/N))-H),\n", " (P,0,N), (H,0,5), \n", " axes_labels=['$P$', '$H$'])\n", "\n", "plt_slope.show()\n", "\n", "\n", "H = 4\n", "plt_slope = plot_slope_field((r*P*(1-(P/N))-H),\n", " (t,0,100),(P,0,N),\n", " axes_labels=['$t$', '$P$'])\n", "\n", "plt_slope.show()" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "var('N, H, r')\n", "N=100\n", "r=0.14\n", "P_plus(H) = (N + sqrt(N^2 - 4*H*N/r))/2\n", "P_minus(H) = (N - sqrt(N^2 - 4*H*N/r))/2\n" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "68.8982236504614\n", "31.1017763495386\n" ] } ], "source": [ "print P_plus(3)\n", "print P_minus(3)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# Taylor Approximation" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "# Linear approximation\n", "f(x) = sin(x)\n", "\n", "x_0 = 0\n", "lin_approx(x) = f(x_0) + f.diff()(x)*(x - x_0)\n", "\n", "plot_f = plot(f(x), (x, -1, 1), \n", " axes_labels=['$x$','$y$'], \n", " color='blue', legend_label='sin(x)')\n", "plot_lin = plot(lin_approx(x), (x, -1, 1), color='red',\n", " legend_label = 'Linear approximation')\n", "\n", "# plotting sin(x) and its linear approximations at x = 0,\n", "show(plot_f + plot_lin)\n", "\n", "\n", "\n", "# Calculating error\n", "print 'sin(pi/6) = %.4f' % (sin(pi/6))\n", "print 'Linear approximation at x = pi/6 = %.4f' % (lin_approx(pi/6))\n", "\n", "print 'Absolute error = %.4f' % abs(sin(pi/6)-lin_approx(pi/6))\n" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "# quadratic approximation\n", "\n", "var('a, b, c, x')\n", "\n", "p(x) = a*x^2 + b*x + c\n", "p.diff()\n", "\n", "p_0 = p(0)\n", "print 'P(0)='\n", "show(p_0)\n", "\n", "p_1st = p.diff()\n", "print 'P_lst(0) = '\n", "show(p_1st(0))\n", "\n", "p_2nd = p_1st.diff()\n", "print 'P_2nd(0) = '\n", "show(p_2nd(0))\n", "# thus a = p_2nd(0)/2\n", "\n", "\n", "# Main equation\n", "f(x) = sin(x)\n", "\n", "f_1st = f.diff()\n", "\n", "f_2nd = f_1st.diff()\n", "\n", "\n", "f_quad(x) = (f_2nd(0)/2)*x^2 + f_1st(0)*x + f(0)\n", "\n", "print 'Quadratic approximation'\n", "show(f_quad(x))\n", "\n", "# Ploting sin(x) and its quadriatic approximation\n", "\n", "plot_sin = plot(sin(x), (x, -1, 1), \n", " axes_labels=['$x$', '$y$'], \n", " legend_label='$f(x) = sin(x)$', \n", " color='blue'\n", " )\n", "\n", "plot_quad = plot(f_quad(x), (x, -1, 1),\n", " axes_labels=['$x$', '$y$'], \n", " legend_label='$Quad approx = x$', \n", " color='red'\n", " )\n", "show(plot_sin + plot_quad)\n", "\n", "\n", "# Error calculation\n", "print 'sin(pi/6) = %.4f' % (f(pi/6))\n", "print 'Quadratic approximation of sin(pi/6) = %.4f' % (f_quad(pi/6))\n", "print 'Error = %.4f' % abs(f_quad(pi/6) - f(pi/6))" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "# Cubic approximation\n", "var('a, b, c, d')\n", "p(x) = a*x^3 + b*x^2+ c*x + d\n", "print 'p(0) = %s' % p(0)\n", "p_1st = p.diff()\n", "print 'p`(0) = %s' % p_1st(0)\n", "p_2nd = p_1st.diff()\n", "print 'p``(0) = %s' % p_2nd(0)\n", "# b = p_2nd(0)/2\n", "p_3rd = derivative(p_2nd, x)\n", "print 'p```(0) = %s' % p_3rd(0)\n", "# a = p_3rd(0)/6\n", "\n", "\n", "f(x) = sin(x)\n", "f_1st = derivative(f(x), x)\n", "f_2nd = derivative(f_1st, x)\n", "f_3rd = derivative(f_2nd, x)\n", "\n", "d = f(0)\n", "c = f_1st(0)\n", "b = f_2nd(0)/2\n", "a = f_3rd(0)/6\n", "\n", "f_cubic(x) = a*x^3 + b*x^2 + c*x + d\n", "show(f_cubic)\n", "\n", "# Ploting sin(x) and its cubic approximation\n", "\n", "plot_sin = plot(f(x), (x, -2, 2), \n", " axes_labels=['$x$', '$y$'], \n", " legend_label='$f(x) = sin(x)$', \n", " color='blue'\n", " )\n", "\n", "plot_cubic = plot(f_cubic(x), (x, -2, 2),\n", " axes_labels=['$x$', '$y$'], \n", " legend_label='$Cubic approximation$', \n", " color='red'\n", " )\n", "show(plot_sin + plot_cubic)\n", "\n", "\n", "# Error calculation\n", "print 'sin(pi/6) = %.4f' % (f(pi/6))\n", "print 'Quadratic approximation of sin(pi/6) = %.4f' % (f_cubic(pi/6))\n", "print 'Error = %.4f' % abs(f_cubic(pi/6) - f(pi/6))" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "# Taylor polynomials\n", "# g)\n", "\n", "def plot_taylor(func, x_range):\n", " f(x) = func\n", " x_range = x_range\n", " plot_all = plot(f(x), x_range, \n", " axes_labels=['$x$', '$y$'], \n", " legend_label=func, \n", " color='blue'\n", " )\n", "\n", " color_taylor = ['orange',\n", " 'red',\n", " 'pink',\n", " 'green',\n", " 'yellow',\n", " 'black'\n", " ]\n", "\n", " for i in range(1, 7):\n", " color = color_taylor[i-1]\n", " legend = '%s approximation' % i\n", " print '%d degree' % i\n", " show(f.taylor(x, 0, i))\n", " plot_i = plot(f.taylor(x, 0, i), x_range,\n", " axes_labels=['$x$', '$y$'], \n", " legend_label=legend, \n", " color=color\n", " )\n", " plot_all += plot_i\n", "\n", "\n", " show(plot_all)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Taylor approximation of f(x)=sin(x)\n", "1 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "2 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "3 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ -\\frac{1}{6} \\, x^{3} + x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "4 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ -\\frac{1}{6} \\, x^{3} + x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "5 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{120} \\, x^{5} - \\frac{1}{6} \\, x^{3} + x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "6 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{120} \\, x^{5} - \\frac{1}{6} \\, x^{3} + x$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "----------------------------------------\n", "Taylor approximation of g(x)=e^x\n", "1 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "2 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{2} \\, x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "3 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{6} \\, x^{3} + \\frac{1}{2} \\, x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "4 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{24} \\, x^{4} + \\frac{1}{6} \\, x^{3} + \\frac{1}{2} \\, x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "5 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{120} \\, x^{5} + \\frac{1}{24} \\, x^{4} + \\frac{1}{6} \\, x^{3} + \\frac{1}{2} \\, x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "6 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{1}{720} \\, x^{6} + \\frac{1}{120} \\, x^{5} + \\frac{1}{24} \\, x^{4} + \\frac{1}{6} \\, x^{3} + \\frac{1}{2} \\, x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "----------------------------------------\n", "Taylor approximation of h(x) = 1/(1-x)\n", "1 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "2 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "3 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x^{3} + x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "4 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x^{4} + x^{3} + x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "5 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x^{5} + x^{4} + x^{3} + x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "6 degree\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ x^{6} + x^{5} + x^{4} + x^{3} + x^{2} + x + 1$ " ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "----------------------------------------\n" ] } ], "source": [ "print 'Taylor approximation of f(x)=sin(x)'\n", "f(x) = sin(x)\n", "plot_taylor(f(x), (x, -2*pi, 2*pi))\n", "print '--'*20\n", "\n", "print 'Taylor approximation of g(x)=e^x'\n", "g(x) = e^x\n", "plot_taylor(g(x), (x, -2*pi, 2*pi))\n", "print '--'*20\n", "\n", "print 'Taylor approximation of h(x) = 1/(1-x)'\n", "h(x) = 1/(1-x)\n", "plot_taylor(h(x), (x, -5, 5))\n", "print '--'*20" ] }, { "cell_type": "code", "execution_count": 136, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f(x)\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{\\sqrt{2} e^{\\left(-\\frac{1}{2} \\, x^{2}\\right)}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "1st Taylor Polynomials\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ \\frac{\\sqrt{2}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Integrate p_1 from [-1, 1] = 0.79788 \n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{\\sqrt{2}}{\\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "2nd Taylor Polynomials\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ -\\frac{\\sqrt{2} x^{2}}{4 \\, \\sqrt{\\pi}} + \\frac{\\sqrt{2}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Integrate p_2 from [-1, 1] = 0.66490 \n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{5 \\, \\sqrt{2}}{6 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "3rd Taylor Polynomials\n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ -\\frac{\\sqrt{2} x^{2}}{4 \\, \\sqrt{\\pi}} + \\frac{\\sqrt{2}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Integrate p_3 from [-1, 1] = 0.66490 \n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{5 \\, \\sqrt{2}}{6 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 136, "metadata": { }, "output_type": "execute_result" } ], "source": [ "# (i)\n", "\n", "print 'f(x)'\n", "f(x) = (1/(sqrt(2*pi)))*e^(-x^2/2)\n", "show(f(x))\n", "\n", "print '1st Taylor Polynomials'\n", "p_1 = f.taylor(x, 0, 1)\n", "show(p_1)\n", "print 'Integrate p_1 from [-1, 1] = %.5f ' % (integrate(p_1, x, -1, 1))\n", "show(integrate(p_1, x, -1, 1))\n", "\n", "print '2nd Taylor Polynomials'\n", "p_2 = f.taylor(x, 0, 2)\n", "show(p_2)\n", "print 'Integrate p_2 from [-1, 1] = %.5f ' % (integrate(p_2, x, -1, 1))\n", "show(integrate(p_2, x, -1, 1))\n", "\n", "print '3rd Taylor Polynomials'\n", "p_3 = f.taylor(x, 0, 3)\n", "show(p_3)\n", "print 'Integrate p_3 from [-1, 1] = %.5f ' % (integrate(p_3, x, -1, 1))\n", "show(integrate(p_3, x, -1, 1))" ] }, { "cell_type": "code", "execution_count": 129, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{\\sqrt{2} e^{\\left(-\\frac{1}{2} \\, x^{2}\\right)}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 129, "metadata": { }, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "Integrate 1 degree Taylor Polynomial from [-1, 1] = 0.7979 \n", "Integrate 2 degree Taylor Polynomial from [-1, 1] = 0.6649 \n", "Integrate 3 degree Taylor Polynomial from [-1, 1] = 0.6649 \n", "Integrate 4 degree Taylor Polynomial from [-1, 1] = 0.6849 \n", "Integrate 5 degree Taylor Polynomial from [-1, 1] = 0.6849 \n", "Integrate 6 degree Taylor Polynomial from [-1, 1] = 0.6825 \n", "Integrate 7 degree Taylor Polynomial from [-1, 1] = 0.6825 \n", "Integrate 8 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 9 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 10 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 11 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 12 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 13 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 14 degree Taylor Polynomial from [-1, 1] = 0.6827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Integrate 15 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 16 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 17 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 18 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "Integrate 19 degree Taylor Polynomial from [-1, 1] = 0.6827 \n", "----------------------------------------\n", "Integrate of f(x) [-1, 1] = 0.6827 \n" ] } ], "source": [ "f(x) = (1/(sqrt(2*pi)))*e^(-x^2/2)\n", "show(f(x))\n", "for i in range(1, 20):\n", "# print '%d degree Taylor Polynomials' % i\n", " f_approx = f.taylor(x, 0, i)\n", " print 'Integration %d degree Taylor Polynomial from [-1, 1] = %.4f ' % (i, integrate(f_approx, x, -1, 1))\n", "\n", "\n", "print '--'*20\n", "print 'Integration of f(x) [-1, 1] = %.4f ' % (integrate(f(x), x, -1, 1))" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Integration of f(x) [-1, 1] = 1.0000 \n" ] }, { "data": { "text/html": [ " $\\newcommand{\\Bold}[1]{\\mathbf{#1}}x \\ {\\mapsto}\\ -\\frac{\\sqrt{2} x^{10}}{7680 \\, \\sqrt{\\pi}} + \\frac{\\sqrt{2} x^{8}}{768 \\, \\sqrt{\\pi}} - \\frac{\\sqrt{2} x^{6}}{96 \\, \\sqrt{\\pi}} + \\frac{\\sqrt{2} x^{4}}{16 \\, \\sqrt{\\pi}} - \\frac{\\sqrt{2} x^{2}}{4 \\, \\sqrt{\\pi}} + \\frac{\\sqrt{2}}{2 \\, \\sqrt{\\pi}}$ " ] }, "execution_count": 133, "metadata": { }, "output_type": "execute_result" } ], "source": [ "f(x) = (1/(sqrt(2*pi)))*e^(-x^2/2)\n", "\n", "f_approx = f.taylor(x, 0, 10)\n", "print 'Integration of f(x) [-1, 1] = %.4f ' % (integrate(f(x), x, -oo, oo))\n", "# print 'Integrate %d degree Taylor Polynomial from [-1, 1] = %.4f ' % (10, integrate(f_approx, x, -oo, oo))\n", "\n", "show(f_approx)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sin(pi/6) = 0.5000\n", "First and second order approximation of sin(pi/6) = 0.5236\n", "Error = 0.0236\n", "sin(pi/6) = 0.5000\n", "Third and fourth order approximation of sin(pi/6) = 0.4997\n", "Error = 0.0003\n", "sin(pi/6) = 0.5000\n", "Fifth and sixth order approximation of sin(pi/6) = 0.5000\n", "Error = 0.0000\n", "sin(8pi) = 0.0000\n", "First and second order approximation of sin(8pi) = 25.1327\n", "Error = 25.1327\n", "sin(8pi) = 0.0000\n", "Third and fourth order approximation of sin(8pi) = -2620.7362\n", "Error = 2620.7362\n", "sin(8pi) = 0.0000\n", "Fifth and sixth order approximation of sin(8*pi) = 80943.0391\n", "Error = 80943.0391\n" ] } ], "source": [ "f_first(x) = x\n", "f_third(x)= -x^3/6+x\n", "f_fifth(x)= x^5/120 -x^3/6+x\n", "\n", "# Error calculation for pi/6\n", "print 'sin(pi/6) = %.4f' % (f(pi/6))\n", "print 'First and second order approximation of sin(pi/6) = %.4f' % (f_first(pi/6))\n", "print 'Error = %.4f' % abs(f_first(pi/6) - f(pi/6))\n", "\n", "print 'sin(pi/6) = %.4f' % (f(pi/6))\n", "print 'Third and fourth order approximation of sin(pi/6) = %.4f' % (f_third(pi/6))\n", "print 'Error = %.4f' % abs(f_third(pi/6) - f(pi/6))\n", "\n", "print 'sin(pi/6) = %.4f' % (f(pi/6))\n", "print 'Fifth and sixth order approximation of sin(pi/6) = %.4f' % (f_fifth(pi/6))\n", "print 'Error = %.4f' % abs(f_fifth(pi/6) - f(pi/6))\n", "\n", "# Error calculation for 8pi\n", "\n", "print 'sin(8pi) = %.4f' % (f(8*pi))\n", "print 'First and second order approximation of sin(8pi) = %.4f' % (f_first(8*pi))\n", "print 'Error = %.4f' % abs(f_first(8*pi) - f(8*pi))\n", "\n", "print 'sin(8pi) = %.4f' % (f(8*pi))\n", "print 'Third and fourth order approximation of sin(8pi) = %.4f' % (f_third(8*pi))\n", "print 'Error = %.4f' % abs(f_third(8*pi) - f(8*pi))\n", "\n", "print 'sin(8pi) = %.4f' % (f(8*pi))\n", "print 'Fifth and sixth order approximation of sin(8*pi) = %.4f' % (f_fifth(8*pi))\n", "print 'Error = %.4f' % abs(f_fifth(8*pi) - f(8*pi))" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e^(0.01) = 1.0101\n", "First order approximation of e^(0.01) = 1.0100\n", "Error = 0.0001\n", "e^(0.01) = 1.0101\n", "Second order approximation of e^(0.01) = 1.0101\n", "Error = 0.0000\n", "e^(0.01) = 1.0101\n", "Third order approximation of e^(0.01) = 1.0101\n", "Error = 0.0000\n", "e^(0.01) = 1.0101\n", "Fourth order approximation of e^(0.01) = 1.0101\n", "Error = 0.0000\n", "e^(0.01) = 1.0101\n", "Fifth order approximation of e^(0.01) = 1.0101\n", "Error = 0.0000\n", "e^(0.01) = 1.0101\n", "Sixth order approximation of e^(0.01) = 1.0101\n", "Error = 0.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "First order approximation of e^(1000) = 101.0000\n", "Error = 26881171418161356094253400435962903554686976.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "Second order approximation of e^(100) = 5101.0000\n", "Error = 26881171418161356094253400435962903554686976.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "Third order approximation of e^(100) = 171767.6667\n", "Error = 26881171418161356094253400435962903554686976.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "Fourth order approximation of e^(100) = 4338434.3333\n", "Error = 26881171418161356094253400435962903554686976.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "Fifth order approximation of e^(1000) = 87671767.6667\n", "Error = 26881171418161356094253400435962903554686976.0000\n", "e^(100) = 26881171418161356094253400435962903554686976.0000\n", "Sixth order approximation of e^(100) = 1476560656.5556\n", "Error = 26881171418161356094253400435962903554686976.0000\n" ] } ], "source": [ "f_first(x) = x+1\n", "f_second(x) = (1/2)*x^2+x+1\n", "f_third(x)= (1/6)*x^3+(1/2)*x^2+x+1\n", "f_fourth(x) = (1/24)*x^4+(1/6)*x^3+(1/2)*x^2+x+1\n", "f_fifth(x)= x^5/120+(1/24)*x^4+(1/6)*x^3+(1/2)*x^2+x+1\n", "f_sixth(x) = (1/720)*x^6+x^5/120+(1/24)*x^4+(1/6)*x^3+(1/2)*x^2+x+1\n", "\n", "# Error calculation for 0.01\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'First order approximation of e^(0.01) = %.4f' % (f_first(0.01))\n", "print 'Error = %.4f' % abs(f_first(0.01) - e^(0.01))\n", "\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'Second order approximation of e^(0.01) = %.4f' % (f_second(0.01))\n", "print 'Error = %.4f' % abs(f_second(0.01) - e^(0.01))\n", "\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'Third order approximation of e^(0.01) = %.4f' % (f_third(0.01))\n", "print 'Error = %.4f' % abs(f_third(0.01) - e^(0.01))\n", "\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'Fourth order approximation of e^(0.01) = %.4f' % (f_fourth(0.01))\n", "print 'Error = %.4f' % abs(f_fourth(0.01) - e^(0.01))\n", "\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'Fifth order approximation of e^(0.01) = %.4f' % (f_fifth(0.01))\n", "print 'Error = %.4f' % abs(f_fifth(0.01) - e^(0.01))\n", "\n", "print 'e^(0.01) = %.4f' % (e^(0.01))\n", "print 'Sixth order approximation of e^(0.01) = %.4f' % (f_sixth(0.01))\n", "print 'Error = %.4f' % abs(f_sixth(0.01) - e^(0.01))\n", "\n", "# Error calculation for 100\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'First order approximation of e^(1000) = %.4f' % (f_first(100))\n", "print 'Error = %.4f' % abs(f_first(100) - e^(100))\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'Second order approximation of e^(100) = %.4f' % (f_second(100))\n", "print 'Error = %.4f' % abs(f_second(100) - e^(100))\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'Third order approximation of e^(100) = %.4f' % (f_third(100))\n", "print 'Error = %.4f' % abs(f_third(100) - e^(100))\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'Fourth order approximation of e^(100) = %.4f' % (f_fourth(100))\n", "print 'Error = %.4f' % abs(f_fourth(100) - e^(100))\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'Fifth order approximation of e^(1000) = %.4f' % (f_fifth(100))\n", "print 'Error = %.4f' % abs(f_fifth(100) - e^(100))\n", "\n", "print 'e^(100) = %.4f' % (e^(100))\n", "print 'Sixth order approximation of e^(100) = %.4f' % (f_sixth(100))\n", "print 'Error = %.4f' % abs(f_sixth(100) - e^(100))" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1/(1-1.01)) = -100.0000\n", "First order approximation of 1/(1-1.01) = 2.0100\n", "Error = 102.0100\n", "1/(1-1.01)) = -100.0000\n", "Second order approximation of 1/(1-1.01) = 3.0301\n", "Error = 103.0301\n", "1/(1-1.01)) = -100.0000\n", "Third order approximation of 1/(1-1.01) = 4.0604\n", "Error = 104.0604\n", "1/(1-1.01)) = -100.0000\n", "Fourth order approximation of 1/(1-1.01) = 5.1010\n", "Error = 105.1010\n", "1/(1-1.01)) = -100.0000\n", "Fifth order approximation of 1/(1-1.01) = 6.1520\n", "Error = 106.1520\n", "1/(1-1.01)) = -100.0000\n", "Sixth order approximation of 1/(1-1.01) = 7.2135\n", "Error = 107.2135\n", "1/(1-0.99)) = 100.0000\n", "First order approximation of 1/(1-0.99) = 1.9900\n", "Error = 98.0100\n", "1/(1-0.99)) = 100.0000\n", "Second order approximation of 1/(1-0.99) = 2.9701\n", "Error = 97.0299\n", "1/(1-0.99)) = 100.0000\n", "Third order approximation of 1/(1-0.99) = 3.9404\n", "Error = 96.0596\n", "1/(1-0.99)) = 100.0000\n", "Fourth order approximation of 1/(1-0.99) = 4.9010\n", "Error = 95.0990\n", "1/(1-0.99)) = 100.0000\n", "Fifth order approximation of 1/(1-0.99) = 5.8520\n", "Error = 94.1480\n", "1/(1-0.99)) = 100.0000\n", "Sixth order approximation of 1/(1-0.99) = 6.7935\n", "Error = 93.2065\n", "1/(1-100)) = -0.0101\n", "First order approximation of 1/(1-100) = 101.0000\n", "Error = 101.0101\n", "1/(1-100)) = -0.0101\n", "Second order approximation of 1/(1-100) = 10101.0000\n", "Error = 10101.0101\n", "1/(1-100)) = -0.0101\n", "Third order approximation of 1/(1-100) = 1010101.0000\n", "Error = 1010101.0101\n", "1/(1-100)) = -0.0101\n", "Fourth order approximation of 1/(1-100) = 101010101.0000\n", "Error = 101010101.0101\n", "1/(1-100)) = -0.0101\n", "Fifth order approximation of 1/(1-100) = 10101010101.0000\n", "Error = 10101010101.0101\n", "1/(1-100)) = -0.0101\n", "Sixth order approximation of 1/(1-100) = 1010101010101.0000\n", "Error = 1010101010101.0101\n" ] } ], "source": [ "f_first(x) = x+1\n", "f_second(x) = x^2+x+1\n", "f_third(x)= x^3+x^2+x+1\n", "f_fourth(x) = x^4+x^3+x^2+x+1\n", "f_fifth(x)= x^5+x^4+x^3+x^2+x+1\n", "f_sixth(x) = x^6+x^5+x^4+x^3+x^2+x+1\n", "\n", "# Error calculation for 1.01\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'First order approximation of 1/(1-1.01) = %.4f' % (f_first(1.01))\n", "print 'Error = %.4f' % abs(f_first(1.01) - 1/(1-1.01))\n", "\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'Second order approximation of 1/(1-1.01) = %.4f' % (f_second(1.01))\n", "print 'Error = %.4f' % abs(f_second(1.01) - 1/(1-1.01))\n", "\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'Third order approximation of 1/(1-1.01) = %.4f' % (f_third(1.01))\n", "print 'Error = %.4f' % abs(f_third(1.01) - 1/(1-1.01))\n", "\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'Fourth order approximation of 1/(1-1.01) = %.4f' % (f_fourth(1.01))\n", "print 'Error = %.4f' % abs(f_fourth(1.01) - 1/(1-1.01))\n", "\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'Fifth order approximation of 1/(1-1.01) = %.4f' % (f_fifth(1.01))\n", "print 'Error = %.4f' % abs(f_fifth(1.01) - 1/(1-1.01))\n", "\n", "print '1/(1-1.01)) = %.4f' % (1/(1-1.01))\n", "print 'Sixth order approximation of 1/(1-1.01) = %.4f' % (f_sixth(1.01))\n", "print 'Error = %.4f' % abs(f_sixth(1.01) - 1/(1-1.01))\n", "\n", "\n", "# Error calculation for 0.99\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'First order approximation of 1/(1-0.99) = %.4f' % (f_first(0.99))\n", "print 'Error = %.4f' % abs(f_first(0.99) - 1/(1-0.99))\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'Second order approximation of 1/(1-0.99) = %.4f' % (f_second(0.99))\n", "print 'Error = %.4f' % abs(f_second(0.99) - 1/(1-0.99))\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'Third order approximation of 1/(1-0.99) = %.4f' % (f_third(0.99))\n", "print 'Error = %.4f' % abs(f_third(0.99) - 1/(1-0.99))\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'Fourth order approximation of 1/(1-0.99) = %.4f' % (f_fourth(0.99))\n", "print 'Error = %.4f' % abs(f_fourth(0.99) - 1/(1-0.99))\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'Fifth order approximation of 1/(1-0.99) = %.4f' % (f_fifth(0.99))\n", "print 'Error = %.4f' % abs(f_fifth(0.99) - 1/(1-0.99))\n", "\n", "print '1/(1-0.99)) = %.4f' % (1/(1-0.99))\n", "print 'Sixth order approximation of 1/(1-0.99) = %.4f' % (f_sixth(0.99))\n", "print 'Error = %.4f' % abs(f_sixth(0.99) - 1/(1-0.99))\n", "\n", "# Error calculation for 100\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'First order approximation of 1/(1-100) = %.4f' % (f_first(100))\n", "print 'Error = %.4f' % abs(f_first(100) - 1/(1-100))\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'Second order approximation of 1/(1-100) = %.4f' % (f_second(100))\n", "print 'Error = %.4f' % abs(f_second(100) - 1/(1-100))\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'Third order approximation of 1/(1-100) = %.4f' % (f_third(100))\n", "print 'Error = %.4f' % abs(f_third(100) - 1/(1-100))\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'Fourth order approximation of 1/(1-100) = %.4f' % (f_fourth(100))\n", "print 'Error = %.4f' % abs(f_fourth(100) - 1/(1-100))\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'Fifth order approximation of 1/(1-100) = %.4f' % (f_fifth(100))\n", "print 'Error = %.4f' % abs(f_fifth(100) - 1/(1-100))\n", "\n", "print '1/(1-100)) = %.4f' % (1/(1-100))\n", "print 'Sixth order approximation of 1/(1-100) = %.4f' % (f_sixth(100))\n", "print 'Error = %.4f' % abs(f_sixth(100) - 1/(1-100))" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[y == -24900]" ] }, "execution_count": 53, "metadata": { }, "output_type": "execute_result" } ], "source": [ "t(y)= 100*ln((y/100)+250)\n", "solve(t==0,y)" ] }, { "cell_type": "code", "execution_count": 141, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "With linear approximation, sin(100.00) = -0.530965\n", "With sixth degree taylor approximation, sin(100.00) = -0.506366\n", "Actual value of sin(100.00) = -0.506366\n", "------------------------------------------------------------\n", "With linear approximation, sin(200.00) = -1.061930\n", "With sixth degree taylor approximation, sin(200.00) = -0.873297\n", "Actual value of sin(200.00) = -0.873297\n", "------------------------------------------------------------\n" ] } ], "source": [ "# Question (i)\n", "\n", "def ceil(quot):\n", " # Rounds off a decimal number to nearest greater number to the function\n", " return int(quot) + 1\n", "\n", "def floor(quot):\n", " # Rounds off a decimal number to nearest smaller number to the function\n", " return int(quot)\n", "\n", "def sin_calculator(x, f_approx):\n", " # Divide the number by pi\n", " quot = float(x/pi)\n", " \n", " if quot % 2 == 0:\n", " # If the quotient is an even number\n", " # subtract x from the product of pi and floor value of the quotient\n", " conv_x = x - floor(quot)*pi\n", " else:\n", " # If the quotient is an even number\n", " # subtract x from the product of pi and ceiling value of the quotient\n", " conv_x = x - ceil(quot)*pi\n", " \n", " # Insert the new converted number the linear approximation function, \n", " # stored in the calculator\n", " return f_approx(conv_x)\n", "\n", "def test_calc(x_input):\n", " # Finding approximation function of sin(x)\n", " var('x')\n", " f(x) = sin(x)\n", " f_approx = f.taylor(x, 0, 1)\n", "\n", " print 'With linear approximation, sin(%.2f) = %.6f' % (x_input, sin_calculator(x_input, f_approx))\n", "\n", " f_approx = f.taylor(x_input, 0, 6)\n", " print 'With sixth degree taylor approximation, sin(%.2f) = %.6f' % (x_input, sin_calculator(x_input, f_approx))\n", "\n", " print 'Actual value of sin(%.2f) = %.6f' % (x_input, sin(x_input))\n", " \n", " print '---'*20\n", " \n", "test_calc(100)\n", "test_calc(200)" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "32\n", "32\n", "32\n" ] } ], "source": [ "print ceil(31.3)\n", "print ceil(31.7)\n", "print floor(32.7)" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 99, "metadata": { }, "output_type": "execute_result" } ], "source": [ "5%2" ] }, { "cell_type": "code", "execution_count": 137, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "31" ] }, "execution_count": 137, "metadata": { }, "output_type": "execute_result" } ], "source": [ "int(31.3)" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] } ], "metadata": { "kernelspec": { "display_name": "SageMath 8.4", "language": "sagemath", "name": "sage-8.4" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.15" } }, "nbformat": 4, "nbformat_minor": 0 }