EGR 103/Concept List Fall 2019

This page will be used to keep track of the commands and major concepts for each lecture in EGR 103.

Lecture 1 - Introduction

• Class web page: EGR 103L; assignments, contact info, readings, etc - see slides on Errata/Notes page
• Sakai page: Sakai 103L page; grades, surveys and tests, some assignment submissions
• Piazza page: Piazza 103L page; message board for questions

Lecture 2 - Programs and Programming

• To play with Python:
  • Install it on your machine or a public machine: Download
• Quick tour of Python
  • Editing window, variable explorer, and console
  • Variable explorer is your friend
• From Dewey - programming language typically have ability to work with input, output, math, conditional execution, and repetition
• Hilton and Bracy Seven Steps
• Class work developing algorithm for program to determine if a number is prime
• Inputs in Python using input() command - always grab strings
• Convert strings containing integer characters to integers using int()
• Some commands are only available by importing from modules; import numpy as np will bring in all the functions of the numpy module. Access these commands by typing np.VALUE or np.FUNCTION (for example, np.pi or np.cos(2))

Lecture 3 - Variable Types

• Python has several different variable types, each with their own purpose and operators.
• Main ones this lecture: int, float, string, tuple, list.

Lecture 4 - Dictionaries and Functions

• Brief discussion of dictionaries, how to build, and how to access.
• Two main types of function - lambda functions and defined functions
• Lambda functions are one line of code; can have multiple inputs but only one expression.
  • c = lambda a,b: np.sqrt(a**2 + b**2)
• Defined functions can be multiple lines of code and have multiple outputs.
  • Four different types of argument:
    • Required (listed first)
    • Named with defaults (second)
    • Additional positional arguments ("*args") (third)
      • Function will create a tuple containing these items in order
    • Additional keyword arguments ("**kwargs") (last)
      • Function will create a dictionary of keyword and value pairs

Lecture 5 - Format, Logic, Decisions, and Loops

• Creating formatted strings using {} and .format() (format strings, standard format specifiers -- focus was on using e or f for type, minimumwidth.precision, and possibly a + in front to force printing + for positive numbers.
• Basics of decisions using if...elif...else
• Basics of loops using for and while
• Building a program to count the number of numbers, vowels, consonants, and other characters in a phrase

Expand

# letter_counter.py from class:

def counter(phrase):
    counts = [0, 0, 0, 0]
    nums = "0123456789"
    vowels = "aeiou"
    cons = "bcdfghjklmnpqrstvwxyz"

    for k in phrase.lower():
        #print(k)
        if k in nums:
            # print('{:s} is a number!'.format(k))
            counts[0] += 1
        elif k in vowels:
            counts[1] += 1
        elif k in cons:
            counts[2] += 1
        else:
            counts[3] += 1
               
    return counts
        
c = counter("Hello! Go 2022! East Campus Rocks!")
print(c)

Lecture 6 - TPIR Example with Decisions and Loops

• The Price Is Right - Clock Game:

Expand

# tpir.py from class:

# -*- coding: utf-8 -*-
"""
The Price Is Right - Clock Game
"""

import numpy as np
import time

def create_price(low, high):
    return np.random.randint(low, high+1)

def get_guess():
    guess = int(input('Guess: '))
    return guess

def check_guess(new_guess, price):
    if new_guess  > price:
        print('${:0.0f} is too high - Lower!'.format(new_guess))
    elif new_guess < price:
        print('Higher!')
    else:
        print('You win!')


price = create_price(100, 1000)
# print(price)
new_guess = price + 1
start_time = time.clock()

while new_guess != price and (time.clock()-start_time)<30:
    new_guess = get_guess()
    # print(new_guess)
    check_guess(new_guess, price)
    
if new_guess != price:
    print('You lose :( '))

Lecture 7 - Input Checking

• Robust programming
• isinstance to check type

Expand

• # validator.py from class:
  

def check_for_int(x):
    '''
    returns true if string contains an valid int
    returns false otherwise
    '''
    for k in x:
        if k not in '0123456789':
            return False

    return True


def get_good():
    x = input('Integer between 0 and 10: ')
    bad = True
    ''' not quite
    while bad:
        if check_for_int(x) is False:
            pass
        elif int(x)>=0 and int(x)<=10:
            bad = False
    return int(x)
    '''
    while bad:
        if check_for_int(x) is False:
            print('Wrong type of input')
            x = input('INTEGER between 0 and 10: ')
        elif int(x) < 0 or int(x) > 10:
            print('Invalid value')
            x = input('Integer BETWEEN 0 and 10: ')
        else:
            bad = False

    return int(x)


if __name__ == "__main__":
    check_for_int('1.1')
    y = get_good()
    print(y)

• Note: my_string.isdigit() works like check_for_int() above

Lecture 8 - Taylor Series and Iterative Solutions

• Taylor series fundamentals
• Maclaurin series approximation for exponential uses Chapra 4.2 to compute terms in an infinite sum.

\( y=e^x=\sum_{n=0}^{\infty}\frac{x^n}{n!} \)

so

\( \begin{align} y_{init}&=1\\ y_{new}&=y_{old}+\frac{x^n}{n!} \end{align} \)

• Newton Method for finding square roots uses Chapra 4.2 to iteratively solve using a mathematical map. To find \(y\) where \(y=\sqrt{x}\): \( \begin{align} y_{init}&=1\\ y_{new}&=\frac{y_{old}+\frac{x}{y_{old}}}{2} \end{align} \)
• See Python version of Fig. 4.2 and modified version of 4.2 in the Resources section of Sakai page under Chapra Pythonified

Lecture 9 - Binary and Floating Point Numbers

• Different number systems convey information in different ways.
  • Roman Numerals
  • Chinese Numbers
  • Ndebe Igbo Numbers
• "One billion dollars!" may not mean the same thing to different people: Long and Short Scales
• Floats (specifically double precision floats) are stored with a sign bit, 52 fractional bits, and 11 exponent bits. The exponent bits form a code:
  • 0 (or 00000000000): the number is either 0 or a denormal
  • 2047 (or 11111111111): the number is either infinite or not-a-number
  • Others: the power of 2 for scientific notation is 2**(code-1023)
    • The largest number is thus just *under* 2**1024 (ends up being (2-2**-52)**1024\(\approx 1.798\times 10^{308}\).
    • The smallest normal number (full precision) is 2**(-1022)\(\approx 2.225\times 10^{-308}\).
    • The smallest denormal number (only one significant binary digit) is 2**(-1022)/2**53 or 5e-324.
  • When adding or subtracting, Python can only operate on the common significant digits - meaning the smaller number will lose precision.
  • (1+1e-16)-1=0 and (1+1e-15)-1=1.1102230246251565e-15
  • Avoid intermediate calculations that cause problems: if x=1.7e308,
    • (x+x)/x is inf
    • x/x + x/x is 2.0

Lecture 10 - Numerical Issues

• List-building roundoff demonstration

Expand

# Roundoff Demo

import numpy as np
import matplotlib.pyplot as plt

start = 10;
delta = 0.1;
finish = 100;

k = 0
val_c = [start];
val_a = [start];

while val_c[-1]+delta <= finish:
   val_c += [val_c[-1] + delta];
   k = k + 1
   val_a += [start + k*delta];

array_c = np.array(val_c)
array_a = np.array(val_a)

diffs = [val_c[k]-val_a[k] for k in range(len(val_a))]

plt.figure(1)
plt.clf()
#plt.plot(array_c - array_a, 'k-')
plt.plot(diffs, 'k-')

• Exponential demo program

Expand

# Exponential demo

#%%
import numpy as np
import matplotlib.pyplot as plt
#%%
def exp_calc(x, n):
    return (1 + (x/n))**n
#%% Shows that apprxomation gets better as n increases
print(np.exp(1))
print(exp_calc(1, 1))
print(exp_calc(1, 10))
print(exp_calc(1, 100))
print(exp_calc(1, 1000))
print(exp_calc(1, 10000))
print(exp_calc(1, 100000))
#%% Shows that once n is too big, problems happen
n = np.logspace(0, 18, 1e3);

plt.figure(1)
plt.clf()
plt.semilogx(n, exp_calc(1, n), 'b-')

• Table showing binary digits in roundoff error:

Expand

# Error table

import numpy as np

for k in np.logspace(15, 20, 300):
    print('{0:.2e} {1:4.0f} {1:012b}'.format(k, int((k+1365)-k)))

• List comprehensions: info in Think Python and Section 7.1.1 in Punch & Enbody
  • Basic idea: make a list of [EXPRESSION for VARIABLE in ITERABLE if LOGIC]
  • Even numbers 0 through 10: [k for k in range(11) if k%2==0]
  • Non-vowels in a word: [letter for letter in word if not letter in 'aeiouAEIOU']
  • Square roots of nonnegative numbers in a list of numbers: [sqrt{n} for n in nums if n>=0]
  • Print all three character codes with each character unique:

Expand

# unique_codes.py

letters = 'howdy'
count = 0
for l1 in letters:
    #print('{}'.format(l1))
    for l2 in [k for k in letters if k not in [l1]]:
        #print('{} {}'.format(l1, l2))
        for l3 in [m for m in letters if m not in [l1, l2]]:
            count += 1
            print('{:4.0f} {} {} {}'.format(count, l1, l2, l3))

• Can also replace letters with whatever should comprise three element code; letters='hello' will make all three letter words out of h, e, l, and o (24 choices) and letters=['1', '2', '3', '4, '5'] will make all three-digit codes

Lecture 11 - Style, Strings and Files

• Discussion of PEP and PEP8 in particular
• Installation and use of autopep8 to make .py files stylistically correct
  • autopep8 FILE.py --aggressive
  • Putting a -i will actually replace FILE.py with better version rather than just showing issues

Lecture 12 - Monte Carlo Methods

• Using repetition to approximate statistics

Expand

# Random walk simulator:

import numpy as np
import matplotlib.pyplot as plt
import math as m

def start_fig(fnum=1):
    fig, ax = plt.subplots(num=fnum)
    fig.clf()
    fig, ax = plt.subplots(num=fnum)
    return fig, ax

def take_step():
    return 2*np.random.randint(0, 2)-1

def take_walk(steps):
    loc = np.zeros(steps+1)
    for k in range(1,steps+1):
        loc[k] = loc[k-1]+take_step()

    return loc


if __name__ == "__main__":
    num_pos=0
    if 0:
        for k in range(1000000):
            x = take_step()
            if x == 1:
                num_pos+=1

        print(num_pos)

    if 0:
        print(take_walk(6))

    num_walkers = 640000
    end_loc = np.zeros(num_walkers)
    for k in range(num_walkers):
        w = take_walk(6)
        end_loc[k] = w[-1]

    fig, ax = start_fig(1)
    ax.hist(end_loc, bins=13, range=(-6.5, 6.5))

Lecture 13 - Linear Algebra I

• 1-D and 2-D Arrays
• Matrix multiplication (using @ in Python)
• Setting up linear algebra equations
• Determinants of matrices and the meaning when the determinant is 0
• Inverses of matrices
• Solving systems of equations

Lecture 14 - Linear Algebra II

• Norms
  • p-norm for 1-D arrays -- mainly 1, 2, or infinity
  • 1, Frobenius, infinity norms for 2-D arrays
  • 2 norm for 2-D arrays -- harder to calculate but most used -- VERY different way of finding from 2-norm of a 1-D array
• Condition numbers
• log10(condition number) = number of digits of precision lost due to system geometry

Lecture 20 - Roots and Extrema

• Python:Finding roots
• SciPy references (all from Optimization and root finding):
  • scipy.optimize.brentq - closed method root finding
  • scipy.optimize.fsolve - open method root finding
  • scipy.optimize.fmin - unbounded minimization
  • scipy.optimize.fminbound - bounded minimization