Week3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CS2 FUNCTIONS: LARGEST NUMBER ##\n",
    "def is_larger(n1,n2): \n",
    " return (n1 - n2) > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CS3 FUNCTIONS AND CONDITIONS ##\n",
    "def letter_grade(mark):\n",
    " marks = float(mark)\n",
    " if type(mark) != int:\n",
    "  return None\n",
    " elif marks<0 and marks>100:\n",
    "  return None\n",
    " elif marks >= 90 and marks <= 100:\n",
    "  return \"A\"\n",
    " elif marks < 90 and marks >= 80:\n",
    "  return \"B\"\n",
    " elif marks < 80 and marks >= 70:\n",
    "  return \"C\"\n",
    " elif marks < 70 and marks >= 60:\n",
    "  return \"D\"\n",
    " elif marks < 60 and marks > 0:\n",
    "  return \"E\"\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CS4 LOOPS: SUMMATION ##\n",
    "import math\n",
    "def list_sum(ls):\n",
    " return math.fsum(ls) #REBEL\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CS5 LOOPS: MAXIMUM ##\n",
    "def minmax_in_list(ls):\n",
    " if ls == []:\n",
    "  return None,None\n",
    " else:\n",
    "    i = 0\n",
    "    mi = ma = ls[0]\n",
    "    while i < len(ls):\n",
    "        if ls[i] > ma:\n",
    "            ma = ls[i]\n",
    "        if ls[i] < mi:\n",
    "            mi = ls[i]\n",
    "        i += 1\n",
    "    return mi, ma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CS6 FUNCTIONS: PALINDROME ##\n",
    "def is_palindrome(num):\n",
    " reverse_num = str(num)[::-1]\n",
    " return reverse_num == str(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## HW1 FUNTIONS: ARGUMENTS ##\n",
    "def check_value(n1,n2,n3,x):\n",
    " if x > n1 and x>n2 and x<n3:\n",
    "  return True\n",
    " else:\n",
    "  return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## HW2 FUNCTIONS ##\n",
    "def fahrenheit_to_celsius(F):\n",
    "    C = (F-32)*float(5)/9\n",
    "    return C\n",
    "\n",
    "def celsius_to_fahrenheit(C):\n",
    "    F = C*float(9)/5 + 32\n",
    "    return F\n",
    "  \n",
    "def temp_convert(choice, temp):\n",
    " if choice == \"C\":\n",
    "  return fahrenheit_to_celsius(temp)\n",
    " elif choice == \"F\":\n",
    "  return celsius_to_fahrenheit(temp)\n",
    " else:\n",
    "  return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## HW3 FUNCTIONS: EVEN ##\n",
    "def get_even_list(ls):\n",
    " x = []\n",
    " for i in ls:\n",
    "  if i % 2 == 0:\n",
    "   x.append(i)\n",
    " return x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## HW4 FUNCTIONS: PRIME ##\n",
    "def is_prime(n):\n",
    "    return n > 1 and all(n % i for i in range(2, n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## HW5 EULER'S METHOD ##\n",
    "import math\n",
    "\n",
    "def f(t, y):\n",
    "    return 3.0+math.exp(-t)-0.5*y\n",
    "\n",
    "def approx_ode(h,t0,y0,tn):\n",
    " t,y = t0,y0\n",
    " while abs(t - tn) > h/2.:\n",
    "  y += h * f(t,y)\n",
    "  t += h\n",
    " return round(y,3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EX1 FUNCTIONS: TYPES ##\n",
    "def may_ignore(x):\n",
    "   if type(x) != int:\n",
    "    return None\n",
    "   else:\n",
    "        x+=1\n",
    "   return x   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EX2 FUNCTIONS: REVERSE ##\n",
    "def my_reverse(list1):\n",
    "  ls = []\n",
    "  counter = len(list1) - 1\n",
    "  while counter >= 0:\n",
    "    ls.append(list1[counter])\n",
    "    counter -= 1\n",
    "  return ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EX3 FUNCTIONS AND LOOPS: APPROXIMATION OF PI ##\n",
    "from math import *\n",
    "def approx_pi(n):\n",
    "    summ = 0\n",
    "    for i in range(n):       \n",
    "       summ +=  (factorial(4*i) * (1103 +26390*i)) / ((factorial(i)**4) * 396**(4*i))\n",
    "       i += 1  \n",
    "    pi = ((2*sqrt(2)/9801) * summ)**-1\n",
    "    return pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EX4 LOOPS: GCD ##\n",
    "def gcd(a,b):\n",
    "  while b:\n",
    "   a, b = b, a % b\n",
    "  return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "## EX5 SIMPSON'S RULE FOR NUMERICAL INTEGRATION ##\n",
    "def simpsons_rule(f, n, a, b):\n",
    " h = (b - a)/float(n) \n",
    " sum1 = 0\n",
    " for i in range(1, int(n/2 + 1)):\n",
    "  sum1 += f(a + (2*i - 1)*h)\n",
    " sum1 *= 4\n",
    " sum2 = 0\n",
    " for i in range(1, int(n/2)): \n",
    "  sum2 += f(a + 2*i*h)\n",
    " sum2 *= 2\n",
    " approx = h/3. *(f(a) + f(b) + sum1 + sum2)\n",
    " return approx\n",
    "    \n",
    "######### Defining test functions ###########\n",
    "def f1(x):\n",
    "    return x**2\n",
    "\n",
    "def f2(x):\n",
    "    return math.sin(x)\n",
    "\n",
    "def f3(x):\n",
    "    return math.exp(-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "## DWCHEM Q4 NORMALISED ANGULAR SOLUTION ##\n",
    "import numpy as np\n",
    "from math import pi, sqrt, cos, factorial, e\n",
    "\n",
    "def angular_wave_func(m,l,theta,phi):\n",
    "\n",
    " eps = -1**m if m > 0 else 1\n",
    " expr = sqrt((((2*l) + 1) * factorial(l - abs(m))) / ((4.0*pi) * factorial(l + abs(m))))\n",
    " p = assoc_legendre(m, l)(theta)\n",
    " e_part = (e**(m*phi*1j))\n",
    " y = eps * expr * e_part * p\n",
    " return np.round(y, 5)\n",
    "\n",
    " \n",
    "def legendre(l):\n",
    "    if l == 0:\n",
    "        return lambda x: 1 \n",
    "    p = np.poly1d([1, 0, -1]).__pow__(l) \n",
    "    p_deriv = p.deriv(l) \n",
    "    legendre_pol = p_deriv/(2**l * factorial(l))\n",
    " \n",
    "    def getpol(theta):\n",
    "        pol = 0\n",
    "        for power, coeff in enumerate(legendre_pol):\n",
    "            pol += coeff*(cos(theta)**power)\n",
    "        return pol\n",
    "     \n",
    "    return legendre_pol \n",
    "     \n",
    "def assoc_legendre(m,l):\n",
    "    if l == 0 and m == 0:\n",
    "        return lambda x: 1 \n",
    " \n",
    "    elif abs(m) <= l:\n",
    "        legendre_pol = legendre(l)\n",
    "        legendre_pol_deriv = legendre_pol.deriv(abs(m)) if m != 0 else legendre_pol\n",
    " \n",
    "        def getassoc(theta):\n",
    "            return legendre_pol_deriv(cos(theta))*((1 - cos(theta)**2)**abs(m/2.0))\n",
    "        return getassoc \n",
    "    else:\n",
    "        return lambda x: \"m cannot be greater than l\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## DWCHEM Q5 NORMALISED RADIAL SOLUTION ##\n",
    "from math import sqrt, factorial\n",
    "import numpy as np\n",
    "import scipy.constants as c\n",
    "\n",
    "def radial_wave_func(n, l, r):\n",
    "    a=c.physical_constants['Bohr radius'][0]\n",
    "    p = 2*l +1\n",
    "    qmp = n - l -1\n",
    "    x = (2*r)/(n*a)\n",
    "    lfunc= assoc_laguerre(p,qmp)\n",
    "    y = lfunc(x)\n",
    "    norm_rad_sol = (sqrt(((2/(n*a))**3)*((factorial(qmp)/(2.0*n*(factorial(n +l))**3))))*np.exp(-r/(n*a))*x**l*y)/a**(-1.5)\n",
    "    return np.round(norm_rad_sol,5)\n",
    "\n",
    "def laguerre(q):\n",
    "    def pascal(rows): \n",
    "        for rownum in range (rows):\n",
    "            newValue = 1\n",
    "            psc = [newValue]\n",
    "            for iteration in range (rownum):\n",
    "                newValue = newValue * (rownum - iteration) * 1 / (iteration + 1)\n",
    "                psc.append(int(newValue))\n",
    "        return psc\n",
    "    coef = []\n",
    "    for term in range(q + 1):\n",
    "        c = ((-1)**(q + term))*(pascal(q + 1)[term])*(factorial(q)/factorial(q - term))\n",
    "        coef.append(c)\n",
    "    return np.poly1d(coef) \n",
    "\n",
    "def assoc_laguerre(p, qmp):\n",
    "    q = qmp + p\n",
    "    lag = laguerre(q)\n",
    "    lag_der = lag.deriv(p)\n",
    " \n",
    "    def getassoc(x):\n",
    "        value = (-1**p) * lag_der(x)\n",
    "        return value\n",
    " \n",
    "    return getassoc"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}