EGR 103/Concept List Spring 2020

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
• Pundit page: EGR 103; reference lists
• CampusWire page: CampusWire 103L page; message board for questions - you need to be in the class and have the access code 6393 to subscribe.

Lecture 2 - Programs and Programming

• Seven steps of programming -
• Watch video on Developing an Algorithm
• Watch video on A Seven Step Approach to Solving Programming Problems

Lecture 3 - "Number" Types

• To play with Python:
  • Install it on your machine or a public machine: Download
• Quick tour of Python
  • Editing window, variable explorer, and console
  • Run icon (F5)
• You are not expected to remember any of the specifics about how Python stores things or works with them yet!
• Python is a "typed" language - variables have types
• We will use eight types:
  • Focus of the day: int, float, and array
  • Basics today, focus a little later: string, list, tuple
  • Focus later: dictionary, set
• int: integers; Python can store these perfectly
• float: floating point numbers - "numbers with decimal points" - Python sometimes has problems storing floating point items exactly
• array
  • Requires numpy, usually with import numpy as np
  • Organizational unit for storing rectangular arrays of numbers
• Math with "Number" types works the way you expect
  • ** * / // % + -
• Slices allow us to extract information from a collection or change information in mutable collections
• a[0] is the element in a at the start
• a[3] is the element in a three away from the start
• a[-1] is the last element of a
• A string contains an immutable collection of characters
  • Using + with strings concatenates strings
  • Using * with strings makes a string with the original repeated
• A tuple contains an immutable collection of other types
  • Using + with tuples concatenates tuples
  • Using * with tuples makes a tuple with the original repeated
• A list contains an immutable collection of other types
  • Using + with lists concatenates lists
  • Using * with lists makes a list with the original repeated

Lecture 4 - More on Types

• Relational operators can compare "Number" Types and work the way you expect with True or False as an answer
  • < <= == >= > !=
  • With arrays, either same size or one is a single value; result will be an array of True and False the same size as the array
• More advanced slices:
• a[:] is all the elements in a because what is really happening is:
  • a[start:until] where start is the first index and until is just *past* the last index;
  • a[3:7] will return a[3] through a[6] in 4-element array
  • a[start:until:increment] will skip indices by increment instead of 1
  • To go backwards, a[start:until:-increment] will start at an index and then go backwards until getting at or just past until.
• For 2-D arrays, you can index items with either separate row and column indices or indices separated by commas:
  • a[2][3] is the same as a[2, 3]
  • Only works for arrays!

Lecture 5 - Printing and Decisions

• 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.
• Also - Format Specification Mini-Language

Lecture 6 - Decisions

• Rolling dice

# tpir.py from class:

def roll(num=1, sides=6):
    print(num, sides)
    dice = np.random.randint(1, sides+1, num)
    print(dice)
    return dice

• Checking rolls:

# tpir.py from class:

import numpy as np

def eval_hand(dice):
    sorted_dice = dice*1
    sorted_dice.sort()
    if sorted_dice[0] == sorted_dice[-1]:
        hand_type = 3
        tie_value = [sorted_dice[0]]
    elif (sorted_dice[0] == sorted_dice[1]-1 and
          sorted_dice[0] == sorted_dice[2]-2):
        hand_type = 2
        tie_value = [sorted_dice[2]]
    elif (sorted_dice[1] == sorted_dice[0] or
          sorted_dice[1] == sorted_dice[2]):
        hand_type = 1
        tie_value = [sorted_dice[1]]
        if sorted_dice[1] == sorted_dice[0]:
            tie_value += [sorted_dice[2]]
        else:
            tie_value += [sorted_dice[0]]
    else:
        hand_type = 0
        tie_value = sorted_dice[::-1]
    return hand_value, tie_value

Lecture 7 - Loops

• The Price Is Right - Clock Game video demonstration

# tpir.py from class:

import numpy as np

def create_price(low=100, high=1500):
    return np.random.randint(low, high+1)
    
def get_guess():
    guess = int(input('Guess: '))
    return guess
    
def check_guess(actual, guess):
    if actual > guess:
        print('Higher!')
    elif actual < guess:
        print('Lower!')

if __name__ == '__main__':
    the_price = create_price()
    the_guess = get_guess()
    while the_price != the_guess:
        check_guess(the_price, the_guess)
        the_guess = get_guess()
    
    if the_price==the_guess:    
        print('You win!!!!!!!')
    else:
        print('LOOOOOOOOOOOOOOOSER')

• Getting temperatures:

# get_temps.py from class:

T = int(input('Temp: '))
Tlist = []
while T>=0:
    Tlist += [T]
    print(Tlist)

    T = int(input('Temp: '))

Lecture 8 - Iterative Methods

• 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