Difference between revisions of "EGR 103/Concept List Fall 2019"

From PrattWiki
Jump to navigation Jump to search
(Lecture 7 - Applications)
Line 220: Line 220:
 
</div>
 
</div>
 
</div>
 
</div>
 
<!--
 
 
== Lecture 6 - TPIR Example with Decisions and Loops ==
 
* The Price Is Right - Clock Game:
 
<div class="mw-collapsible mw-collapsed">
 
<source lang=python>
 
# tpir.py from class:
 
</source>
 
<div class="mw-collapsible-content">
 
<source lang=python>
 
# -*- 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 :( '))
 
</source>
 
</div>
 
</div>
 
 
== Lecture 7 - Input Checking ==
 
* Robust programming
 
* isinstance to check type
 
<div class="mw-collapsible mw-collapsed">
 
*<source lang=python>
 
# validator.py from class:
 
</source>
 
<div class="mw-collapsible-content">
 
<source lang=python>
 
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)
 
 
</source>
 
</div>
 
</div>
 
*Note: my_string.isdigit() works like check_for_int() above
 
  
 
== Lecture 8 - Taylor Series and Iterative Solutions ==
 
== Lecture 8 - Taylor Series and Iterative Solutions ==
Line 354: Line 249:
 
** Chinese Numbers
 
** Chinese Numbers
 
** Ndebe Igbo Numbers
 
** Ndebe Igbo Numbers
 +
** Binary Numbers
 +
*** We went through how to convert between decimal and binary
 +
** [https://en.wikipedia.org/wiki/Kibibyte Kibibytes] et al
 
* "One billion dollars!" may not mean the same thing to different people: [https://en.wikipedia.org/wiki/Long_and_short_scales Long and Short Scales]
 
* "One billion dollars!" may not mean the same thing to different people: [https://en.wikipedia.org/wiki/Long_and_short_scales 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:
 
* Floats (specifically double precision floats) are stored with a sign bit, 52 fractional bits, and 11 exponent bits.  The exponent bits form a code:
Line 367: Line 265:
 
*** (x+x)/x is inf
 
*** (x+x)/x is inf
 
*** x/x + x/x is 2.0
 
*** x/x + x/x is 2.0
 +
* In cases where mathematical formulas have limits to infinity, you have to pick numbers large enough to properly calculate values but not so large as to cause errors in computing:
 +
** $$e^x=\lim_{n\rightarrow \infty}\left(1+\frac{x}{n}\right)^n$$
 +
<div class="mw-collapsible mw-collapsed">
 +
<source lang=python>
 +
# Exponential Demo
 +
</source>
 +
<div class="mw-collapsible-content">
 +
<syntaxhighlightlang=python>
 +
import numpy as np
 +
import matplotlib.pyplot as plt
 +
 +
def exp_calc(x, n):
 +
    return (1 + x/n)**n
 +
 +
if __name__ == "__main__":
 +
    n = np.logspace(0, 17, 1000)
 +
    y = exp_calc(1, n)
 +
    fig, ax = plt.subplots(num=1, clear=True)
 +
    ax.semilogx(n, y)
 +
    fig.savefig('ExpDemoPlot1.png')
 +
   
 +
    # Focus on right part
 +
    n = np.logspace(13, 16, 1000)
 +
    y = exp_calc(1, n)
 +
    fig, ax = plt.subplots(num=2, clear=True)
 +
    ax.semilogx(n, y)
 +
    fig.savefig('ExpDemoPlot2.png')
 +
</syntaxhighlight>
 +
</div>
 +
</div>
 +
<gallery>
 +
File:ExpDemoPlot1.png|estimates for calculating $$e$$ with $$n$$ between 1 and $$1*10^{17}$$
 +
File:ExpDemoPlot2.png|$$n$$ between $$10^{13}$$ and $$10^{16}$$ showing region when roundoff causes problems
 +
</gallery>
 +
 +
<!--
 +
  
 
== Lecture 10 - Numerical Issues ==
 
== Lecture 10 - Numerical Issues ==

Revision as of 21:05, 23 September 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
  • CampusWire page: CampusWire 103L page; message board for questions - you need to be in the class and have the access code to subscribe.

Lecture 2 - Programs and Programming

Lecture 3 - "Number" Types

  • Python is a "typed" language - variables have types
  • We will use eight types:
    • Focus of the day: int, float, and array
    • 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
  • 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
    • ** * / // % + -
  • 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
  • Slices allow us to extract information from an array or put information into an array
  • a[0] is the element in a at the start
  • a[3] is the element in a three away from the start
  • 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 4 - Other Types and Functions

  • Lists are set off with [ ] and entries can be any valid type (including other lists!); entries can be of different types from other entries
  • List items can be changed
  • Tuples are indicated by commas without square brackets (and are usually shown with parentheses - which are required if trying to make a tuple an entry in a tuple or a list)
  • Dictionaries are collections of key : value pairs set off with { }; keys can be any immutable type (int, float, string, tuple) and must be unique; values can be any type and do not need to be unique
  • To read more:
    • Note! Many of the tutorials below use Python 2 so instead of print(thing) it shows print thing
    • Lists at tutorialspoint
    • Tuples at tutorialspoint
    • Dictionary at tutorialspoint
  • Defined functions can be multiple lines of code and have multiple outputs.
    • Four different types of input parameters:
      • 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
    • Function ends when indentation stops or when the function hits a return statement
    • Return returns single item as an item of that type; if there are multiple items returned, they are stored in a tuple
    • If there is a left side to the function call, it either needs to be a single variable name or a tuple with as many entries as the number of items returned

Lecture 5 - Format, Logic, Decisions, and Loops

Lecture 6 - String Things and Loops

  • ord to get numerical value of each character
  • chr to get character based on integer
  • map(fun, sequence) to apply a function to each item in a sequence
  • Basics of while loops
  • Basics of for loops
  • List comprehensions
    • [FUNCTION for VAR in SEQUENCE if LOGIC]
      • The FUNCTION should return a single thing (though that thing can be a list, tuple, etc)
      • The "if LOGIC" part is optional
      • [k for k in range(3)] creates [0, 1, 2]
      • [k**2 for k in range (5, 8)] creates [25, 36, 49]
      • [k for k in 'hello' if k<'i'] creates ['h', 'e']
      • [(k,k**2) for k in range(11) if k%3==2] creates [(2, 4), (5, 25), (8, 64)]
    • Wait - that's the simplified version...here:
  • Want to see Amharic?
list(map(chr, range(4608, 4992)))
  • Want to see the Greek alphabet?
for k in range(913,913+25):
    print(chr(k), chr(k+32))

Lecture 7 - Applications

# tpir.py from class:
import numpy as np
import time

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__':
    #print(create_price(0, 100))
    the_price = create_price()
    the_guess = get_guess()
    start_time = time.clock()
    #print(the_guess)
    while the_price != the_guess and (time.clock() < start_time+30):
        check_guess(the_price, the_guess)
        the_guess = get_guess()
    
    if the_price==the_guess:    
        print('You win!!!!!!!')
    else:
        print('LOOOOOOOOOOOOOOOSER')
# nato_trans.py from class:
fread = open('NATO.dat', 'r')

d = {}

for puppies in fread:
    #print(puppies) $ if you want to see the whole line
    
    #key = puppies[0]
    #value = puppies[:-1]
    #d[key] = value
    
    d[puppies[0]] = puppies[:-1]

fread.close()

hamster = input('Word: ').upper()

for kittens in hamster:
    #print(d[letter], end=' ')
    print(d.get(kittens, 'XXX'), end=' ')
    
'''
In class - one question was "in cases where there is not a code, can it
return the original value instead of XXX" -- yes:
    print(d.get(kittens, kittens))
'''
  • Data file we used:
# NATO.dat from class:
Alfa
Bravo
Charlie
Delta
Echo
Foxtrot
Golf
Hotel
India
Juliett
Kilo
Lima
Mike
November
Oscar
Papa
Quebec
Romeo
Sierra
Tango
Uniform
Victor
Whiskey
X-ray
Yankee
Zulu

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
    • Binary Numbers
      • We went through how to convert between decimal and binary
    • Kibibytes et al
  • "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
  • In cases where mathematical formulas have limits to infinity, you have to pick numbers large enough to properly calculate values but not so large as to cause errors in computing:
    • $$e^x=\lim_{n\rightarrow \infty}\left(1+\frac{x}{n}\right)^n$$
# Exponential Demo

<syntaxhighlightlang=python> import numpy as np import matplotlib.pyplot as plt

def exp_calc(x, n):

   return (1 + x/n)**n

if __name__ == "__main__":

   n = np.logspace(0, 17, 1000)
   y = exp_calc(1, n)
   fig, ax = plt.subplots(num=1, clear=True)
   ax.semilogx(n, y)
   fig.savefig('ExpDemoPlot1.png')
   
   # Focus on right part
   n = np.logspace(13, 16, 1000)
   y = exp_calc(1, n)
   fig, ax = plt.subplots(num=2, clear=True)
   ax.semilogx(n, y)
   fig.savefig('ExpDemoPlot2.png')

</syntaxhighlight>