Math_for_CS_101.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "175.0\n"
     ]
    }
   ],
   "source": [
    "# Calculate GCD & LCM, greatest common divisor and least common multiple with one function.\n",
    "\n",
    "def GCD(a,b):\n",
    "    c = max(a,b)\n",
    "    d = min(a,b)\n",
    "    if d == 0: return c\n",
    "    return GCD(c%d, d)\n",
    "print(GCD(125,225))\n",
    "\n",
    "\n",
    "def LCM(a,b):\n",
    "    gcd = GCD(a,b)\n",
    "    product = a * b\n",
    "    lcm = product / gcd\n",
    "    return lcm\n",
    "\n",
    "print(LCM(35,25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "160.0\n"
     ]
    }
   ],
   "source": [
    "# Calculate the GCD and LCM of an array of integers. \n",
    "# Take the first 2 and then call GCD function for each remaining item with an updated new gcd value in every iteration\n",
    "\n",
    "test_array = [16, 40, 32]\n",
    "\n",
    "def GCD_of_array(array):\n",
    "    n = len(array)\n",
    "    if n < 2: return array\n",
    "    gcd = GCD(array[0], array[1])\n",
    "    for i in range(2,n):\n",
    "        gcd = GCD(gcd, array[i])\n",
    "    return gcd        \n",
    "    \n",
    "    \n",
    "print(GCD_of_array(test_array)) \n",
    "\n",
    "\n",
    "def LCM_of_array(array):\n",
    "    n = len(array)\n",
    "    if n < 2: return array\n",
    "    lcm = LCM(array[0], array[1])\n",
    "    for i in range(2,n):\n",
    "        lcm = LCM(lcm, array[i])\n",
    "    return lcm\n",
    "\n",
    "print(LCM_of_array(test_array))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2999999999999923\n",
      "0.3\n"
     ]
    }
   ],
   "source": [
    "# Calculate GCD of floating numbers\n",
    "\n",
    "import numpy as np \n",
    "def gcd_floating_numbers(a,b) : \n",
    "    c = max(a,b)\n",
    "    d = min(a,b)\n",
    "    if d < 0.0001: return c\n",
    "    return gcd_floating_numbers(c-d, d)\n",
    "\n",
    "a = 1.20\n",
    "b = 22.5\n",
    "result = gcd_floating_numbers(a, b)\n",
    "print(result)\n",
    "print(np.around(result, decimals = 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Find largest subsequence having GCD that is greater than 1 with O(n * max(arr[i]))\n",
    "\n",
    "def largest_GCD_Subsequence(arr): \n",
    "    n = len(arr)\n",
    "    max_count = 0\n",
    "    max_item = max(arr)\n",
    "    for i in range(2, max_item + 1): # for each value from 2 to the max value of array, check all items of the array\n",
    "        count = 0\n",
    "        for j in range(n): # for each value, find the maximum possible divisor bigger than 1 for all values \n",
    "            if (arr[j] % i == 0): \n",
    "                count += 1\n",
    "        if max_count < count:\n",
    "            max_count = count\n",
    "  \n",
    "    return max_count \n",
    "\n",
    "arr = [8, 12, 3, 6, 2, 5, 7, 4, 10, 20, 1] \n",
    "size = len(arr) \n",
    "print(largest_GCD_Subsequence(arr)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 3, 5, 7]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print all prime factors of a given number\n",
    "\n",
    "import numpy as np\n",
    "def print_prime_factors(n): \n",
    "    # check every number dividing n between 2, square root of n. \n",
    "    # create a list and append every number dividing n\n",
    "    list_of_prime_factors = []\n",
    "    sqrt_of_n = int(np.sqrt(n))   \n",
    "    for i in range(2, sqrt_of_n+1): \n",
    "        while n % i == 0 and n > 1: \n",
    "            list_of_prime_factors.append(i) \n",
    "            n = n / i \n",
    "              \n",
    "    # if n is a prime number greater than 2, add it to the list\n",
    "    if n > 2: \n",
    "        list_of_prime_factors.append(n) \n",
    "        \n",
    "    return list_of_prime_factors\n",
    "\n",
    "print_prime_factors(315) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fermat test to check if a number is prime\n",
    "\n",
    "def fermat_test(n):\n",
    "    # check if n is an even number\n",
    "    if n % 2 == 0:\n",
    "        return False\n",
    "    # a is a natural number between 1, to n-1. \n",
    "    # if a**p-1 in mod p is always 1 for all values of a, then p is prime\n",
    "    for i in range(2, n-1):\n",
    "        if ((i**(n-1)) % n) != 1:\n",
    "            return False\n",
    "    return True\n",
    "    \n",
    "# for i in range(3,20):\n",
    "#    print(i, fermat_test(i))  \n",
    "    \n",
    "fermat_test(317)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  1  2  3  5  8 13 21 34 55]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show fibonacchi numbers\n",
    "\n",
    "def fibonacchi(n):\n",
    "    # create an array\n",
    "    dp = np.zeros(n+1,dtype = int)\n",
    "    dp[1] = 1\n",
    "    # fill the array with the fib sequence a, b = b, a+b\n",
    "    for i in range(2, n+1):\n",
    "        dp[i] = dp[i-1] + dp[i-2]\n",
    "    print(dp)\n",
    "    return dp[n]\n",
    "\n",
    "fibonacchi(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Enter a number to sum up its digits\n",
    "\n",
    "def sum_up_digits(n):\n",
    "    if n < 10 : return n\n",
    "    string_n = str(n)\n",
    "    total = 0\n",
    "    for i in string_n:\n",
    "        int_i = int(i)\n",
    "        total += int_i\n",
    "    return total\n",
    "\n",
    "sum_up_digits(3225)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modular multiplicative inverse\n",
    "# a x ≡ 1 (mod m) condition: if a and m are relatively prime where gcd(a,m) = 1\n",
    "# Ex if a = 4, m = 11 multiplicative inverse of 4 in mod m is 3.\n",
    "\n",
    "# Fermat's theorem to find the primality:   a**(m-1) ≡ 1 (mod m) \n",
    "# which means 1 = a**(m-1) mod m. Multiply both sides by a**-1 =>  a**-1 = a**(m-2) mod m \n",
    "# a inverse can be obtained a to the power of m-2 in mod m\n",
    "\n",
    "# if an only if both a and m are prime, the function will find the inverse of a in mod m\n",
    "def modular_multiplicative_inverse(a,m):\n",
    "    check_a = fermat_test(a)\n",
    "    check_m = fermat_test(m)\n",
    "    if check_a and check_m:\n",
    "        mni = (a**(m-2)) % m \n",
    "    return mni\n",
    "modular_multiplicative_inverse(7,11)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the exponentiation property of modular arithmetic:\n",
    "A^B mod C = ( (A mod C)^B ) mod C\n",
    "#### multiplication property of modular arithmetic:\n",
    "(A * B) mod C = (A mod C * B mod C) mod C\n",
    "#### bonus:\n",
    "(A / B) mod C = (A mod (B*C)) / mod B \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300820513\n"
     ]
    }
   ],
   "source": [
    "# Multiply long integers with modular division\n",
    "# Theory 1: a mod(D) = (x1*x2*x3…….xn) each x individually in mod(D) \n",
    "# Theory 2: (a/b) % mod p is (a % mod(p*b)) / b \n",
    "\n",
    "\n",
    "# Calculate: (51827 * 75022 *  91553 * 49252 * 872299) / 120) % 1000000007 =?\n",
    "test_array = [51827 , 75022 ,  91553 , 49252 , 872299]\n",
    "test_array2 = [55555 , 55554 , 55553 , 55552 , 55551]\n",
    "\n",
    "ans = 1\n",
    "mod = 1000000007 * 120  \n",
    "for i in test_array2: \n",
    "    ans = (ans * i) % mod  \n",
    "    # ans *= (i % mod)\n",
    "ans = int(ans/120) # since we made the calculation on (mod * 120), we need the answer in original mod value.\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def binomial_coef(a,b):\n",
    "    if b >= a: \n",
    "        a, b = b, a\n",
    "    nom = 1\n",
    "    denom = 1\n",
    "    for i in range(a-b+1,a+1):\n",
    "        nom *= i\n",
    "    for j in range(1,b+1):\n",
    "        denom *= j\n",
    "    return nom/denom\n",
    "\n",
    "binomial_coef(6,3)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  0  0  0  0  0  0]\n",
      " [ 1  1  0  0  0  0  0]\n",
      " [ 1  2  1  0  0  0  0]\n",
      " [ 1  3  3  1  0  0  0]\n",
      " [ 1  4  6  4  1  0  0]\n",
      " [ 1  5 10 10  5  1  0]\n",
      " [ 1  6 15 20 15  6  1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Theory: C(n, k) = C(n-1, k-1) + C(n-1, k) calculated dynamically given C(n, 0) = C(n, n) = 1\n",
    "\n",
    "def binomial_coef_table(n,k): # Binomial Coefficient table is pascal table!\n",
    "    dp = np.zeros([n+1,k+1], dtype = int)\n",
    "    dp[:, 0] = 1\n",
    "    for i in range(1, n+1):\n",
    "        for j in range(1, k+1):\n",
    "            if i == j:\n",
    "                dp[i][j] = 1\n",
    "            else:\n",
    "                dp[i][j] = dp[i-1][j-1] + dp[i-1][j]\n",
    "    print(dp)\n",
    "    return dp[6][3]\n",
    "    \n",
    "    \n",
    "binomial_coef_table(6,6)   \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4862.0\n"
     ]
    }
   ],
   "source": [
    "# Compute Catalan Numbers \n",
    "# Catalan number(n) = 1/(n+1) * binomial_coef(2n, n)\n",
    "\n",
    "catalan_9 = binomial_coef(2*9, 9) / 10\n",
    "print(catalan_9)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<matplotlib.lines.Line2D at 0x7f9222e31dd0>],\n",
       " array([ 20000.  ,  36000.  ,  56800.  ,  83840.  , 118992.  , 164689.6 ,\n",
       "        224096.48, 301325.42, 401723.05, 532239.97]),\n",
       " 532239.97)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the investment growth with a regular income and regular interest for over n years.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "# you bring an **initial investment** to your fidelity account at year 0\n",
    "# there is exactly **net interest** net profit from stocks every year after taxes. Ex: value 0.2 means 20 percent. \n",
    "# you bring fresh money into the investment account every year from your paycheks or other businesses\n",
    "# what is the value of your money going to be in ** years ** starting from this year?\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def value_in_10_years(initial_investment, net_interest, new_amount_added_each_year, years):\n",
    "    memo = np.zeros(years)\n",
    "    memo[0] = initial_investment # at year 0\n",
    "    for i in range(1, years):\n",
    "        memo[i] = ((1 + net_interest))*memo[i-1] + new_amount_added_each_year\n",
    "    return plt.plot(np.arange(years), memo) , np.around(memo, decimals = 2), np.around(memo[years-1], decimals = 2)\n",
    "\n",
    "value_in_10_years(20000, 0.30, 10000, 10) \n",
    "\n",
    "# In 10 years, you will have half a million dollars. \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ab', 'cd', 'AB', 'CD']\n",
      "[5, 7, 10, 10, 14, 20]\n"
     ]
    }
   ],
   "source": [
    "# Reminder that if you keep appending its items to a list, it will go infinity. Make sure to use [:].\n",
    "# If not, complexity is infinity. This is a very important thing to pay attention in making some array calculations. \n",
    "\n",
    "x = ['ab', 'cd']\n",
    "for i in x[:]:\n",
    "    x.append(i.upper())\n",
    "print(x)\n",
    "\n",
    "x = [5, 7, 10]\n",
    "for i in x[:]:\n",
    "    x.append(i*2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Show the relationship between Dot and Cross Product of 2 vectors:\n",
    "\n",
    "# Dot Product is the vector multiplication in each dimention:\n",
    "# A = 3 * i + 5 * j + 4 * k    B = 2 * i + 7 * j + 5 * k\n",
    "# dot product A.B = 3 * 2 + 5 * 7 + 4 * 5  = 61\n",
    "\n",
    "\n",
    "# Cross Product of 2 vectors is the determinant of 3x3 vector:\n",
    "# cross product = (a2 * b3 – a3 * b2) * i + (a3 * b1 – a1 * b3) * j + (a1 * b2 – a2 * b1) * k\n",
    "# [i j k]\n",
    "# [3 5 4]\n",
    "# [2 7 5]\n",
    "\n",
    "\n",
    "# The cross product and the dot product are related by:\n",
    "# ||AxB||**2 = ||A|| * ||B|| - (A.B)**2 \n",
    "# Where A.B is ||A|| * ||B|| * cosTETHA\n",
    "# using (sinTETHA)**2 = 1 - cosTETHA**2\n",
    "# So, ||AxB|| = ||A|| * ||B|| * sinTETHA"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}