Lab04_Q3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3 Part a (6.10 Newman)\n",
    "The question asks us to use the relaxation method on a function and then examine the accuracy and other parameters of the function. Particularly, how how the root of the function $ 1 - e^{-cx} $ changes with values of $c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:33.749800Z",
     "start_time": "2018-10-04T22:22:33.742934Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pylab as plt\n",
    "matplotlib.rcParams['figure.figsize'] = (7, 7)\n",
    "matplotlib.rcParams['font.size'] = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:34.199507Z",
     "start_time": "2018-10-04T22:22:34.193159Z"
    }
   },
   "outputs": [],
   "source": [
    "def Relax_Error(f_x,f_xprime, func_deriv,f_constant= 1.0):\n",
    "    # Define the Relaxation Error using a function, it's derivative\n",
    "    # and two floats of successive estimates of x\n",
    "    return (f_x - f_xprime)/(1-(1/func_deriv(f_x,f_constant)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:34.573169Z",
     "start_time": "2018-10-04T22:22:34.565819Z"
    }
   },
   "outputs": [],
   "source": [
    "def Offset_Exponential(f_x, f_constant = 1.0):\n",
    "    # The equation given. I defined a default for the constant \n",
    "    #so the code is more modularized for use in later parts\n",
    "    return 1 - np.exp(-1*f_constant*f_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:34.891194Z",
     "start_time": "2018-10-04T22:22:34.883359Z"
    }
   },
   "outputs": [],
   "source": [
    "def Exponential_Derivative(f_x, f_constant = 1.0):\n",
    "    # The derivative of the above function\n",
    "    return f_constant*np.exp(-1*f_constant*f_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:35.267237Z",
     "start_time": "2018-10-04T22:22:35.258219Z"
    }
   },
   "outputs": [],
   "source": [
    "def Root_Estimator(function, function_deriv, f_constant = 1.0,f_x =0.1):\n",
    "    # This code estimates roots using relaxation method\n",
    "    counter = 0   # counting steps\n",
    "    f_error = 1   # meaningless default error\n",
    "    f_errorlimit = 10**(-6)             # limit of error for order 10^-6\n",
    "    # while loop for the error above the threshold OoM\n",
    "    while np.abs(f_error) > f_errorlimit:   \n",
    "        f_xnew = function(f_x,f_constant)   # calculates a new estimate\n",
    "        f_error = Relax_Error(f_x,f_xnew,function_deriv,f_constant)\n",
    "        # the above line calculates the error\n",
    "        f_x = f_xnew  # redefines the initial guess\n",
    "        counter += 1\n",
    "    #print('The final answer is...',f_x)\n",
    "    #print('COMPLETE')\n",
    "    return f_x, counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:22:35.690800Z",
     "start_time": "2018-10-04T22:22:35.686807Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7968111529033527\n"
     ]
    }
   ],
   "source": [
    "# Part A\n",
    "# Testing that the functions work for c = 2\n",
    "f_constant = 2.0\n",
    "f_x,i_steps  = Root_Estimator(Offset_Exponential, Exponential_Derivative,f_constant)\n",
    "print(f_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:24:26.006766Z",
     "start_time": "2018-10-04T22:24:19.791577Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "a_constant = np.arange(0.01,3,0.01)     # define an array of different constants to sample\n",
    "a_xval = np.empty(len(a_constant))   # empty array to be filled\n",
    "a_steps = np.empty(len(a_constant))  # number of steps each run take\n",
    "                                     # for loop to test each sample\n",
    "for i in range(len(a_constant)): \n",
    "    #print(a_constant[i])\n",
    "    a_xval[i], a_steps[i] = Root_Estimator(Offset_Exponential, Exponential_Derivative,a_constant[i])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:26:03.140674Z",
     "start_time": "2018-10-04T22:26:02.964923Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Root of Nonlinear Function as a function of Constant')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.scatter(a_constant,a_xval, s = 3)\n",
    "plt.xlabel('Constant(C)')\n",
    "plt.ylabel('Root(x)')\n",
    "plt.title('Root of Nonlinear Function as a function of Constant')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3 Part B\n",
    "Now Question 6.11B just wanted to adapt 6.10 code to count the number of steps it took for c = 2. For 6.11C we will compare the number of steps for relaxation method versus overrelaxation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:27:06.907150Z",
     "start_time": "2018-10-04T22:27:06.902853Z"
    }
   },
   "outputs": [],
   "source": [
    "def Root_Overestimator(function, function_deriv,f_constant = 1):\n",
    "    # same relaxation function except with overrelaxation\n",
    "    f_x = 0.1  # initial guess\n",
    "    f_w = 0.75 # overstepping parameter\n",
    "    counter = 0  # initial counter\n",
    "    f_error = 1  # initial meaningless error\n",
    "    f_errorlimit = 10**(-6)             \n",
    "    while np.abs(f_error) > f_errorlimit:\n",
    "        f_xnew = (1+f_w)*function(f_x,f_constant)-f_w*f_x  # overrelaxation method \n",
    "        f_error = Relax_Error(f_x,f_xnew,function_deriv,f_constant)\n",
    "        f_x = f_xnew\n",
    "        counter += 1\n",
    "    #print('The final answer is...',f_x)\n",
    "    #print('COMPLETE')\n",
    "    return f_x, counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:29:28.003589Z",
     "start_time": "2018-10-04T22:29:27.999105Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7968121277836699\n"
     ]
    }
   ],
   "source": [
    "# 6.11, checking 6.10 with Overestimnator now\n",
    "f_constant = 2.0\n",
    "f_x,i_oversteps  = Root_Overestimator(Offset_Exponential, Exponential_Derivative,f_constant)\n",
    "print(f_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:29:28.787513Z",
     "start_time": "2018-10-04T22:29:28.783506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 relaxation method step number\n",
      "8 overrelaxation method step number\n"
     ]
    }
   ],
   "source": [
    "print('relaxation method step number...', i_steps )\n",
    "print('overrelaxation method step number...', i_oversteps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 6.11c\n",
    "Here it is quite clear that the overstepping method takes less than half the number of iterated steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-03T15:41:40.410461Z",
     "start_time": "2018-10-03T15:41:40.404001Z"
    }
   },
   "source": [
    "##### Question 6.11D\n",
    "Yes, Newman states that a $w > 0 $ changes $x$ by some amount larger than the original $\\Delta x$. If the derivative was steep enough that you needed very small changes, then a negative $w$ would be useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 6.13\n",
    "The question wants us to solve another nonlinear equation, this time with the binary search function and the Newton Method. With this, we can estimate the surface temperature of the sun.\n",
    "The function is \n",
    "\\begin{equation}\n",
    "5e^{-x}+x-5 = 0\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:27.148028Z",
     "start_time": "2018-10-04T22:46:27.137843Z"
    }
   },
   "outputs": [],
   "source": [
    "def Binary_Search(function):\n",
    "    f_errorlimit = 10**(-6)   \n",
    "    f_error = 1\n",
    "    #\n",
    "    f_x1 =  2\n",
    "    f_x2 =  10\n",
    "    counter = 0\n",
    "    while np.abs(f_error) > f_errorlimit:\n",
    "    #for i in range(10):\n",
    "        f_val1 = function(f_x1)\n",
    "        f_val2 = function(f_x2)\n",
    "        #print(f_val1, f_val2)\n",
    "        if np.sign(f_val1) != np.sign(f_val2):\n",
    "            f_midpoint = (f_x1+f_x2)/2.0\n",
    "            f_midval = function(f_midpoint)\n",
    "            #print(f_midpoint)\n",
    "        else:\n",
    "            print('Something is very wrong #1')\n",
    "        #print(f_x1, f_x2, f_midpoint)\n",
    "        if np.sign(f_midval) != np.sign(f_val1):\n",
    "            f_x2 = f_midpoint\n",
    "        elif np.sign(f_midval) != np.sign(f_val2):\n",
    "            f_x1 = f_midpoint\n",
    "        else:\n",
    "            print('Something is very wrong #2')\n",
    "        f_error = np.abs(f_val1 - f_val2)\n",
    "        counter += 1\n",
    "    return (f_x1 + f_x2)/2.0 , counter\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:27.475225Z",
     "start_time": "2018-10-04T22:46:27.469396Z"
    }
   },
   "outputs": [],
   "source": [
    "def Newton_Method(Wein_Displacement_Relax, Wein_Displacement_Deriv,f_guess):\n",
    "    counter = 0\n",
    "    f_error = 100\n",
    "    f_errorlimit = 10**(-6)   \n",
    "    while np.abs(f_error) > f_errorlimit:\n",
    "        f_xnew = f_guess - Wein_Displacement(f_guess)/Wein_Displacement_Deriv(f_guess)\n",
    "        f_error = f_xnew - f_guess\n",
    "        f_guess = f_xnew\n",
    "        counter += 1\n",
    "    return(f_xnew, counter)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:27.830723Z",
     "start_time": "2018-10-04T22:46:27.820276Z"
    }
   },
   "outputs": [],
   "source": [
    "def Wein_Displacement(x):\n",
    "    '''\n",
    "    input of a float x \n",
    "    output of a float computed for Wein's Displacement Constant\n",
    "    '''\n",
    "    return  5*np.exp(-1*x) + x -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:28.149483Z",
     "start_time": "2018-10-04T22:46:28.144202Z"
    }
   },
   "outputs": [],
   "source": [
    "def Wein_Displacement_Deriv(x):\n",
    "    '''\n",
    "    input and output of a float\n",
    "    derivative of  Weins Displacement Constant nonlinear calculator\n",
    "    '''\n",
    "    return -5*np.exp(-1*x) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:28.490510Z",
     "start_time": "2018-10-04T22:46:28.484712Z"
    }
   },
   "outputs": [],
   "source": [
    "def Wein_Displacement_Relax(x, f_constant = 1):\n",
    "    '''\n",
    "    input and output of a float\n",
    "    Wein's Displacement Constant rewritten to solve for roots\n",
    "    '''\n",
    "    return 5 - 5*np.exp(-1*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:28.502536Z",
     "start_time": "2018-10-04T22:46:28.495416Z"
    }
   },
   "outputs": [],
   "source": [
    "def Wein_Displacement_Relax_Deriv(x, f_constant = 1):\n",
    "    '''\n",
    "    input and output of a float\n",
    "    Wein's Displacement Constant derivative rewritten to solve for roots\n",
    "    '''\n",
    "    \n",
    "    return 5*np.exp(-1*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:28.512755Z",
     "start_time": "2018-10-04T22:46:28.506873Z"
    }
   },
   "outputs": [],
   "source": [
    "def Wein_Constant(f_solution):\n",
    "    f_planck   = 6.62607004*10**-34     # Planck's Constant\n",
    "    f_boltzman = 1.38064852*10**-23     # Boltzman Constant\n",
    "    f_light    = 299792458             #Speed of light\n",
    "    f_factor = (f_planck/f_boltzman)*f_light\n",
    "    # calculate the Wein's Displacement constant given certain natural constants\n",
    "    return f_factor/f_solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:28.631496Z",
     "start_time": "2018-10-04T22:46:28.623045Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.002897772842539955\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "# Calculate Wein's Displacement Constant using Binary Search\n",
    "f_exp_answer, i_binary_steps = Binary_Search(Wein_Displacement)\n",
    "f_const_answer = Wein_Constant(f_exp_answer)\n",
    "print(f_const_answer)\n",
    "print(i_binary_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:29.698905Z",
     "start_time": "2018-10-04T22:46:29.688366Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.002897772942109512\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Calculate Wein's Displacement Constant using Relaxation Method\n",
    "f_exp_answer2, i_root_steps = Root_Estimator(Wein_Displacement_Relax, Wein_Displacement_Relax_Deriv,f_x =2 )\n",
    "f_const_answer2 = Wein_Constant(f_exp_answer2)\n",
    "print(f_const_answer2)\n",
    "print(i_root_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:31.419804Z",
     "start_time": "2018-10-04T22:46:31.409016Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.002897772914526216\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Calculate Wein's Displacement Constant using Newton's Method\n",
    "f_exp_answer3, i_newt_steps = Newton_Method(Wein_Displacement_Relax, Wein_Displacement_Deriv, 2)\n",
    "f_const_answer3 = Wein_Constant(f_exp_answer3)\n",
    "print(f_const_answer3)\n",
    "print(i_newt_steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 6.13C \n",
    "The question wants us to calculate the surface temperature of the sun. I can rewrite the Wein Displacement law as \n",
    "\\begin{equation}\n",
    "T = \\frac{b}{\\lambda}\n",
    "\\end{equation} \n",
    "and then just plug in the wavelength $\\lambda = 502\\text{ nm}$ and the value of the displacement constant from above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-04T22:46:35.333376Z",
     "start_time": "2018-10-04T22:46:35.328222Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the surface temperature(K) of the Sun is... 5772.455861633377\n"
     ]
    }
   ],
   "source": [
    "f_surface_temp = f_const_answer/(502*10**-9)\n",
    "print('the surface temperature(K) of the Sun is...',f_surface_temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note on the Accuracy of Surface Temperature\n",
    "Wikipedia defines the surface temperature of the sun as approx. $5778$K. This means are errors are of the order $10^{-3}$\n"
   ]
  },
  {
   "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.6.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}