from platform import python_version
print(python_version())
# This is a comment. Use comments to describe code.
# You can uncomment chunks using Cntrl (or Cmd for Macs) + /
x = 5 #int
v = 2.0 #float
z = False #bool
y = "Hello World" #string
#You can also initialize multiple comma-separated variables at once:
a,b,c = 1,2,3 # Creates the three variables a,b,c, and assigns them values 1,2,3, respectively
d = e = f = 5 # creates three variables d, e, f and assigns them all the value 5
print(x)
print(v, z, y) # You can print multiple comma-separated values at once
print(d, e, f) # They will appear with spaces between them
print(type(x))
print(type(y))
print(type(z))
print(type((1,2,3))) # This is a tuple; a series of values enclosed in parentheses and separated by commas.
x = 5+3-2
print(x)
x = 7*6/2
print(x)
# Order of operations is enforced, and parentheses are supported
x = (5+3)*2 / 4
print(x)
# Exponentiation is supported with the (**) operator
x = 2**3
print(x)
# Other built-in operators are the modulo operator (%), which calculated the 'remainder' of division between two values...
x = 17%4
print(x)
#... as well as the floor division operator (//), which gives the result of divison between two values rounded down to the nearest integer.
x = 17//4
print(x,y)
x = 5.0
print(x)
x += 3 # Update the value of x "in place" by adding 3
print(x)
x /= 2 # Update the value of x "in place" by dividing 2
print(x)
# You can also use the variable itself in an update expression in Python.
x = 5.0
x = x + x*x
print(x)
x = 5.0
print(x == 5)
print(x <= 5)
print(x < 5)
print(not(x <= 5))
print(not(x == 10))
y = 3.0
print((y == 50.) or ( x== 5.0))
print((y == 50.) and ( x== 5.0))
print(not((y == 50.) and ( x == 5.0)))
print(not((y == 3.0) or ( x == 5.0)))
print(True == False)
x = [1, 2, 3, 4, 5] # This is a list
print(len(x)) # print the number of elements (length) of lis
print(x[0]) # print the first element
print(x[-1]) # print the last element (in general you can also index from the last element using negative indexes)
print(x[0:2]) # print the first 2 elements
print(x[0:4:2]) # print every other element starting from the first to the 4th
print(3 in x) # check if the number 3 is in the list x
print(7 in x) # check if the number 7 is in the list x
# You can mutate lists (add or subtract elements) in-place
x.append(6) # add 6 to the end of the list
print(x)
x.remove(4) # remove the 4th element of the list
print(x)
x[3] = 7
print(x) # replace the 4th element of the list with a 7
#You can also use lists that contain other lists. The number of nested lists can be thought of as a 'dimension'.
y = [[1, 2], [3, 4], [5, 6]] #This is a 2-D list (list of lists)
print(len(y))
print(y[0]) # access the first row
print(y[0][0]) # access the first element of the first row
print(y[1:3][0:2])
# You will find that we will use large, multidimensional lists/arrays (i.e. matrices and tensors) frequently in most numerical applications.
x = [1.0, 2.0, 3.0, 4.0, 5.0]
y = 6
print(x*y)
x = [1.0, 2.0, 3.0, 4.0, 5.0]
counter = 0 # Start with index 0
while counter < len(x): # As long as we're working with an index found in x
x[counter] *= 6 # Multiply the element at the counter index by 6
counter += 1 # Iterate the counter so that we move to the next index on our next pass through this code block.
print(x)
# Notice that the block of code has stopped executing now that the counter has reached a value of 5;
# at this point the conditional in the 'while' loop is no longer true and the indented block of code stops running.
print(counter)
x_values = [1.0, 2.0, 3.0, 4.0, 5.0]
new_x = [] # Initialize an empty list to hold our new values
for x_value in x_values: # For all of the elements 'i' in list x:
new_x.append(x_value * 6) # Multiply the element by 6 and add it to the new list.
print(new_x)
x_values = [1.0, 2.0, 3.0, 4.0, 5.0]
for i in range(len(x)): # For all indices in list x
x_values[i] *= 6 # Mutate the element at that index by multiplying it with 6
print(x)
x = [1.0, 2.0, 3.0, 4.0, 5.0]
x = [y*6 for y in x] #x is the list of each element 'y' of x multiplied by 6
print(x)
import numpy as np
x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]) # notice the prefix "np." This tells python which module to look at to find the function "array"
y = x*6
print(y)
# sqrt(2.0) # this will yield NameError: name 'sqrt' is not defined
print(np.sqrt(2.0))
a = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0]
b = [4.0, 3.0, 5.0, 6.0, 4.0, 3.0]
# While Loop:
assert len(a) == len(b), "Lengths of lists are not the same!"
counter = 0
c_while = []
while counter < len(a):
c_while.append(a[counter]-0.1*b[counter])
counter += 1
c_for = [] # reinitialize c
# For loop:
for a_i, b_i in zip(a, b):
c_for.append(a_i - 0.1*b_i)
a_array, b_array = np.array(a), np.array(b) # turn lists into numpy arrays
c_numpy = a_array - 0.1*b_array
#(Challenge) List comprehension:
c_comp = [a_i - 0.1*b_i for a_i, b_i in zip(a, b)]
# this is an example of an f-string, it allows the automatic "f"ormatting of strings
print(f"while loop result: {c_while}\nfor loop result: {c_for}\nnumpy result:{c_numpy}\ncomprehension result: {c_comp}")
x = 5
if (x % 2 == 0): # the % symbol is known as the modulo operator. It gives the remainder after integer division.
print("x is even")
else:
print("x is odd")
y = 3
if (x > y):
print("x is greater than y")
elif (x < y):
print("x is less than y")
else:
print("x is equal to y")
# Write your code here:
input_var = "Hello Aadil & Sai"
if type(input_var) is int:
print(input_var*3)
elif type(input_var) is float:
print(0.5*input_var)
elif type(input_var) is str:
print(len(input_var))
elif type(input_var) is bool:
print(not input_var)
else:
raise NotImplementedError
def sum(list_to_sum):
"""Finding the sum of all the elements in a list
Args:
list_to_sum: The list whose elements will be summed over
Returns:
list_sum: the total sum of the list
"""
list_sum = 0
for i in list_to_sum:
list_sum += i
return list_sum
#Verify that this function works
x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
z = [2, 4, 6, 8]
w = [1, 3, 5, 7]
print(sum(x))
print(sum(y))
print(sum(z))
print(sum(w))
#Write your function here:
def my_control_flow_fn(input_var):
if type(input_var) is int:
output_var = input_var*3
elif type(input_var) is float:
output_var = 0.5*input_var
elif type(input_var) is str:
output_var = len(input_var)
elif type(input_var) is bool:
output_var = not input_var
else:
# raise NotImplementedError # this is the Pythonic way to indicate that something is not supported
output_var = "Not Implemented!" # doing this to make sure notebook doesn't crash
return output_var
#Test the funtion here:
print(my_control_flow_fn(2))
print(my_control_flow_fn(3.0))
print(my_control_flow_fn("Hello!"))
print(my_control_flow_fn(True))
print(my_control_flow_fn([1,2,3,4]))
def greet(name="Aadil", time_of_day="morning"):
"""Prints a greeting
Args:
name: A string indicatnig the name to gree
time_of_day: A string indicating the time of day
"""
print("Hello, " + name + ". Good " + time_of_day + "!")
greet() # This will run the generic arguments
greet(time_of_day="evening") #If we want to change a generic argument, we state it ths way
greet(name="Joseph")
greet(name="Professor Onori", time_of_day="afternoon")
# You can mix and match generic arguments with arguments that always require user input as well.
#Write the function here:
def list_subtraction_fn(in1, in2, m=0.1):
# this is how to test to make sure that the function inputs meet intended specifications
assert len(in1) == len(in2), "Print length of input lists don't match!"
return [a_i - m*b_i for a_i, b_i in zip(in1, in2)]
#Test the function here
a = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0]
b = [4.0, 3.0, 5.0, 6.0, 4.0, 3.0]
print(list_subtraction_fn(a,b))
import matplotlib.pyplot as plt # for plotting
fig, ax = plt.subplots()
# This is the simplest way to create a plot with Pyplot. The 'fig' object represents the entire figure you will
# create, and the 'ax' object represents the axes you will plot on. By passing a value or tuple to subplots(),
# you can create multiple axes or a grid of axes that all belong to the same figure. Here, we just create
# one set of axes by leaving the argument blank.
#Let's generate some data to plot:
x = np.linspace(0,10,100)
y = (x-3)**3
#The plot function plots the data on the axes as a graph
ax.plot(x,y)
#We also ought to adorn our axes with the appropriate titles and legends:
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('A Simple Function')
ax.legend(['The Simple Function']) # Legends take a list of labels, in case you've plotted more than one curve on the axes
#Though it's not necessary here, we can also adjust the axis limits:
#ax.set_xlim(-10,10)
#ax.set_ylim(-0,100)
#When the plot is ready, use fig.show()
fig.show()
#If necessary, you can easily save a figure you've generated with fig.savefig()
# fig.savefig("this_is_my_figure.pdf")
# You can also plot on 3D axes with Pyplot
fig, ax = plt.subplots(subplot_kw=dict(projection='3d')) # We can't pass the projection argument directly to subplot(), so we generate the axes in two steps
# To plot a surface, create a 'meshgrid' of points in the x,y plane:
x = np.linspace(0,10,100)
y = np.linspace(0,10,100)
X,Y = np.meshgrid(x,y)
# You can then evaluate a 2D function on the meshgrid coordinates, then plot the surface
Z = np.sin(X)+np.cos(Y)
ax.plot_surface(X,Y,Z, cmap = 'coolwarm') # Trying out different colormaps is fun!
# We can also add axis labels and such:
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('My Lumpy Function')
# For surfaces, it isn't trivial to set up a legend, but you can do so easily for scatter plots and such
ax.set_zlim(-1.1,1.1)
ax.view_init(20,30) # This sets the perspective angle from which we view the graph
from scipy.optimize import curve_fit # a function that allows curve fitting
np.random.seed(13) # seed a random number generator we will use to mimic noise in data
def fit_func(t_data, A, a, B, b):
"""Define the function that we want to fit. See associated documentation for the order of arguments in function call."""
return A*np.exp(a*t_data) + B*np.exp(b*t_data)
t = np.linspace(0.0, 3.0, 300) # 300 linearly spaced points in the interval [-2, 2]
y_true = fit_func(t, 1.0, -3.0, 1.0, -2.0)
noise = np.random.normal(loc=0.0, scale=0.1, size=t.size) # define the noise that we will put over top our data
y_noisy = y_true + noise # define the noisy data set as just the true data set with additive noise
fig, ax = plt.subplots()
ax.plot(t, y_true, "k-", label=r"True data")
ax.plot(t, y_noisy, "ko", label=r"Noisy data")
ax.legend(loc="best")
ax.set_xlabel(r"$t$")
ax.set_ylabel(r"$y(t)$")
ax.set_xlim((0.0, 3))
fig.tight_layout()
popt, *_ = curve_fit(fit_func, t, y_noisy)
A_fit, a_fit, B_fit, b_fit = popt # unpack variables
print(A_fit, a_fit, B_fit, b_fit) # print out the fit variables
# define the fit function on a finer grid than the original data
tfine = np.linspace(0.0, 3.0, 1000)
y_fit = fit_func(tfine, A_fit, a_fit, B_fit, b_fit)
fig, ax = plt.subplots()
ax.plot(t, y_true, "k-", label=r"True data")
ax.plot(t, y_noisy, "ko", label=r"Noisy data")
ax.plot(tfine, y_fit, "r--", label=r"Fit to data")
ax.legend(loc="best")
ax.set_xlabel(r"$t$")
ax.set_ylabel(r"$y(t)$")
ax.set_xlim((0.0, 3.0))
fig.tight_layout()
Numerical Ordinary Differential Equations
A particular sub-module of SciPy that will be relevant to us later in the quarter is one that deals with finding numerical solutions for Ordinary Differential Equations. As a simple demonstration, here we will use a combination of numpy and scipy to simulate a particular ODE and we will use pyplot to plot our results.
from scipy.integrate import solve_ivp # a function that allows us to solve initial value problems like the one posed
def ode_func(t, y): # this function returns the value of the right-hand side of the equation at every time step
return -0.5*y + np.cos(np.pi*t) # numpy has the value of pi saved
teval = np.linspace(0.0, 10.0, 101) # define set of timepoints at which to evaluate the solution
soln = solve_ivp(ode_func, # the function returning the RHS of the
t_span=(0.0, 10.0), # the start and end times you care about
y0 = np.array([2.0,]), # specify the initial condition
t_eval=teval) # solve the IVP and get solution at timepoints
So what type of object is `soln', the output of the solve_ivp() function?
type(soln)
print(soln)
We see that the 'soln' object has different attributes and the ones that are relevant are t and y. We can access these attributes and save them to a different variable in the following way
tsim = soln.t # this is known as 'dot notation' and is how you access object attributes
ysoln = soln.y[0] # Aside: the solve_ivp can also solve systems of ODEs and so y can be a matrix
# where each row is the solution for a particular variable in the system.
# In this case, since our ODE only has one variable the matrix is size (1,N) and so we index
# the first row of the matrix
fig, ax = plt.subplots()
ax.plot(tsim, ysoln)
# always label your axes
ax.set_xlabel("t")
ax.set_ylabel("y(t)")
fig.tight_layout()
Ta-da! There's the numerical solution to the non-homogeneous IVP we posed.