Difference between revisions of "EGR 103/Concept List Fall 2019"
Jump to navigation
Jump to search
\(
y=e^x=\sum_{n=0}^{\infty}\frac{x^n}{n!}
\)
\(
\begin{align}
y_{init}&=1\\
y_{new}&=y_{old}+\frac{x^n}{n!}
\end{align}
\)
Line 415: | Line 415: | ||
== Lecture 20 - Roots and Extrema == | == Lecture 20 - Roots and Extrema == | ||
− | + | * [[Python:Finding roots]] | |
+ | * SciPy references (all from [https://docs.scipy.org/doc/scipy/reference/optimize.html Optimization and root finding]): | ||
+ | ** [https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brentq.html scipy.optimize.brentq] - closed method root finding | ||
+ | ** [https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fsolve.html scipy.optimize.fsolve] - open method root finding | ||
+ | ** [https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fmin.html scipy.optimize.fmin] - unbounded minimization | ||
+ | ** [https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fminbound.html scipy.optimize.fminbound] - bounded minimization | ||
Revision as of 01:07, 25 March 2019
This page will be used to keep track of the commands and major concepts for each lecture in EGR 103.
Contents
- 1 Lecture 1 - Introduction
- 2 Lecture 2 - Programs and Programming
- 3 Lecture 3 - Variable Types
- 4 Lecture 4 - Dictionaries and Functions
- 5 Lecture 5 - Format, Logic, Decisions, and Loops
- 6 Lecture 6 - TPIR Example with Decisions and Loops
- 7 Lecture 7 - Input Checking
- 8 Lecture 8 - Taylor Series and Iterative Solutions
- 9 Lecture 9 - Binary and Floating Point Numbers
- 10 Lecture 10 - Numerical Issues
- 11 Lecture 11 - Style, Strings and Files
- 12 Lecture 12 - Monte Carlo Methods
- 13 Lecture 13 - Linear Algebra I
- 14 Lecture 14 - Linear Algebra II
- 15 Lecture 15 - Test Review
- 16 Lecture 16 - Test
- 17 Lecture 17 - Statistics and Curve Fitting 1
- 18 Lecture 18 - Statistics and Curve Fitting 2
- 19 Lecture 19 - Statistics and Curve Fitting 2.5
- 20 Lecture 20 - Roots and Extrema
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
- Four different types of argument:
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
# 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:
# 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
# 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.
- so
- 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
# 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
# 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:
# 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:
# 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
# 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 15 - Test Review
Lecture 16 - Test
Lecture 17 - Statistics and Curve Fitting 1
Lecture 18 - Statistics and Curve Fitting 2
Lecture 19 - Statistics and Curve Fitting 2.5
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