EGR 103/Concept List Spring 2020

From PrattWiki
Revision as of 19:24, 5 February 2020 by DukeEgr93 (talk | contribs)
Jump to navigation Jump to search

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


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

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

# 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
Retrieved from "https://pundit.pratt.duke.edu/piki/index.php?title=EGR_103/Concept_List_Spring_2020&oldid=25351"