Jupyter Notebook and Python

HANDSON:
Turn this cell into a markdown cell.
Write a short introduction about yourself and your research interest.
Try different formatting methods.
* Can you display equations?
* Can you use non-ASCII characters, e.g., emoji?
* Why does CK always add a newline after a period?
* Why does CK always break a long sentence?

# Example: Print a message

print("Hello, world!  Welcome to ASTR 501!")

# HANDSON: Change the message

print("Your custom message here")

# HANDSON: What happen if you just type a message without print?

# HANDSON: Instead of print(), try to use display().
#          Do you know what is the difference?

# Example: variable assignment with different types

i       = 1           # Integer
j       = 2**345      # Integers have arbitrary precision
x       = 3.14        # Float
y       = 4e6         # Float in scientific notation
z       = 5 + 6j      # Complex number
astr    = "Astronomy" # String
is_cool = True        # Boolean

print("i =", i)
print("j =", j)
print("x =", x)
print("y =", y)
print("z =", z)
print("astr =", astr)
print("is_cool =", is_cool)

# HANDSON: Define and print variables

year       = ...
height     = ...
name       = ...
is_student = ...

print("Year:", year)
print("Height:", height)
print("Name:", name)
print("Is student:", is_student)

# Examples of arithmetic

addition       = 1 + 1
subtraction    = 2 - 1
multiplication = 3 * 4
division       = 5 / 2 # this is called "truediv"
division2      = 5 //2 # this is called "floordiv"
remainder      = 5 % 2 # this is called "mod"
power          = 5 **2

print("Addition:",       addition)
print("Subtraction:",    subtraction)
print("Multiplication:", multiplication)
print("Division:",       division)
print("Division2:",      division2)
print("Remainder:",      remainder)
print("Power:",          power)

# HANDSON: test out true division `/`, floor division `//`, and "mod"
#          `%` with different combinations of integers and floating
#          point numbers.
#          Do the results make sense?
#          Can you provide an equation that summarizes the logic of
#          these operators?

# Example: Creating a list
numbers = [1, 2, 3, 4, 5]
print("Original list:", numbers)

# Accessing elements
print("First element:", numbers[0])
print("Last element:", numbers[-1])

# Adding elements
numbers.append(6)
print("List after appending:", numbers)

# Removing last elements
numbers.pop()
print("List after removing last element:", numbers)

# Removing specific elements
numbers.remove(i) # note that `i` was defined above
print("List after removing", i, ":", numbers)

# HANDSON: create your own list and manipulate it.

# Create a list
fruits = ...
print("Fruits:", fruits)

# Add an element to the list
...
print("Fruits:", fruits)

# Remove an item
...
print("Fruits:", fruits)

# HANDSON: lists also support operators.
#          Try using `+` and `*` on lists.
#          What do you get?

# HANDSON: Python has a data structure very similar to list
#          called `tuple`.
#          The syntax to create it is `t = (1, 2, 3, ...)`.
#          Create a tuple and compare it with a list.
#          What's the difference?

# Example: Loop through a list

for number in numbers:
    print("Number:", number)

# Example: Use an iterable instead of a list

for number in range(10):
    print("Number:", number)

# HANDSON: Write a loop to print squares of numbers.
#          Note that we use something called a "formatted string",
#          or "f-strings", here.

...
    print(f"Square of {i} is {i ** 2}")

# Example: Define a function
def greet(name):
    return f"Hello, {name}!  Welcome to ASTR 501!"

# Call the function
message = greet(name)
print(message)

# HANDSON: Function to calculate circle area

def circle_area(radius):
    ...

# Test the function
area = circle_area(5)
print("Area of circle with radius 5:", area)

# Example: Using NumPy
import numpy as np

# Create an array
array = np.array([1, 2, 3, 4, 5])
print("Array:", array)

# Perform operations
squared = array ** 2
print("Squared Array:", squared)

# Generate a range of numbers
linspace = np.linspace(0, 10, 11)
print("Linspace:", linspace)

array = range(10_000)  # you may add underscore to integers to improve readibility.

%%time
# `%%time` is a "magic command" of IPython.
# it prints the wall time for the entire cell.

squared = []
for a in array:
    squared.append(a*a)

array = np.arange(10_000)

%%time

squared = array * array

# HANDSON: NumPy calculations

# Create an array of numbers from 1 to 10
numbers = ...

# Calculate their squares and square roots
squares = ...
roots   = ...

print("Numbers:", numbers)
print("Squares:", squares)
print("Square Roots:", roots)

# Example: Plotting with Matplotlib
import matplotlib.pyplot as plt

# Create data with NumPy
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create a plot with Matplotlib
plt.plot(x, y, '-o', label='sin(x)')
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.legend()
plt.grid()

# Show and save figure
plt.show()  # optional in jupyter notebook
plt.savefig('sin.pdf')

# HANDSON: Create a plot

# Let's try to plot two curves in a single plot
x  = np.linspace(0, 2 * np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Plot both sine and cosine
...
...

# Customize the plot
...

# Show and save figure
...

import numpy as np

a = np.arange(10)   # array with values 0 to 9
print(a)

# Slicing: extract parts of the array
print(a[2:7])       # elements 2 through 6
print(a[:5])        # first 5 elements
print(a[::2])       # every other element

a = np.random.normal(size=(5,4))  # 5x4 random array
print(a)

# Slicing: selecting rows
print(a[1:3])       # rows 1 through 3
print(a[:2])        # first 2 rows
print(a[::2])       # every other row

# Slicing: selecting columns
print(a[:,1:3])       # columns 1 through 3
print(a[:,:2])        # first 2 columns
print(a[:,::2])       # every other columns

# HANDSON: In python, negative indices are valid.
#          Try to use negative indices to access and slice
#          numpy arrays.
#          Does the result match your expectation?

# EXAMPLE: adding vector and scalar

X = np.array([1, 2, 3])
Y = np.array([10])

print(X + Y)   # Y is automatically "broadcast" to match X

# EXAMPLE: adding column and row vectors, i.e., "outer sum"

X = np.arange(3).reshape(3,1)  # column vector
Y = np.arange(3)               # row vector

print("X =\n", X)
print("Y =",   Y)
print("X + Y =\n", X + Y)      # produces a 3x3 matrix

# EXAMPLE: use `np.newaxis` for "outer sum"

X = np.arange(3)  # row vector
Y = np.arange(3)  # row vector

print("X =\n", X)
print("Y =",   Y)
print("X + Y =\n", X[:,np.newaxis] + Y)  # produces a 3x3 matrix

# EXAMPLE: scaling columns of a matrix

M = np.arange(12).reshape(3, 4)
V = np.array([1, 10, 100, 1000])   # 1D array with 4 elements

print("M =\n", M)
print("M * V =\n", M * V)  # V is broadcast across rows

# EXAMPLE: pairwise distances (without loops)

P = np.array([[0, 0], [1, 0], [0, 1]])

# Broadcasting to compute squared distances
D = P[:, np.newaxis, :] - P[np.newaxis, :, :]
DD = np.sum(D**2, axis=-1)

print(DD)

# EXAMPLE: normalizing vectors

V = np.array([[3, 4], [1, 1], [0, 5]])

L = np.sqrt(np.sum(V**2, axis=1))   # shape (3,)
N = V / L[:, np.newaxis]       # broadcast to (3,2)

print(N)

# HANDSON: try to use both reshape() and newaxis to
#          implement outer product of two vectors.

# Dot product of two vectors
X = np.array([1, 2, 3])
Y = np.array([4, 5, 6])
print(np.einsum('i,i->', X, Y))

# Matrix multiplication
A = np.arange(9).reshape(3, 3)
B = np.arange(9, 18).reshape(3, 3)
print(np.einsum('ik,kj->ij', A, B))

# Summing over axes
print(np.einsum('ij->i', A))  # row sums
print(np.einsum('ij->j', A))  # column sums

# HANDSON: try to use einsum() to
#          implement outer product of two vectors.

import matplotlib.pyplot as plt

x = np.linspace(-2, 2, 20)
y = np.linspace(-2, 2, 20)
X, Y = np.meshgrid(x, y)

U = -Y   # vector field component in x
V =  X   # vector field component in y

plt.figure(figsize=(5,5))
plt.quiver(X, Y, U, V)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Vector Field: Rotation Around Origin")
plt.axis("equal")
plt.show()  # optional

# HANDSON: try to use einsum() to compute the norm of the vector field
#          and over (under?) plot it as a "heatmap" with the vector field.
#          What is the advantage (or disadvantage) to use einsum() compared
#          to simple numpy operations?