From 0f96445c1c46b2d20a3cb0ab39b8a051cb8cd9bb Mon Sep 17 00:00:00 2001
From: Anisha Kalgi <k_anisha@icloud.com>
Date: Mon, 12 May 2025 15:43:45 -0700
Subject: [PATCH 1/4] numpy files

---
 .DS_Store                   | Bin 0 -> 6148 bytes
 plotly/.DS_Store            | Bin 0 -> 6148 bytes
 plotly/ArithmeticInNumpy.py | 164 +++++++++++++++++++
 plotly/ArraysInNumpy.py     | 277 +++++++++++++++++++++++++++++++
 plotly/IntroToNumpy.py      | 316 ++++++++++++++++++++++++++++++++++++
 5 files changed, 757 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 plotly/.DS_Store
 create mode 100644 plotly/ArithmeticInNumpy.py
 create mode 100644 plotly/ArraysInNumpy.py
 create mode 100644 plotly/IntroToNumpy.py

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..469bcd3edac83e85f2ae623ca3146a225f9d4d0a
GIT binary patch
literal 6148
zcmeHKL2uJA6n<_?ldT~20B9GaNL;5;*oHK5DP4Quz-2{n092Bu+oEN0)ugLNRjFtA
z5BvqL{1NysoZx%5hmy1$hXDCi_H*p-dv-qCaZN;`GYuaSHHpYYVqe=tw#K-f(~4D0
z4U>h6aX}-RJd5Qph*!|I!YW`D_}diVz3b3`Qr@|g+rKhE3%5Q++WDajC89d{Kr=q0
zRPXg)*v}<wjY6Q0DJ$Z{y%KJdx+G~xXKED36j4m066a%yQ%CHn;)E2Gu-{AAyBNci
z5}-50mMHn?VL)TNv!oN`KAqziq2;6)t8!9`<<fJYd8BK{S@~MR-$V~%)i1|?53U(Q
zv7hQ;iB|_J1~)@~S;VS2`Ba#b95$Gx;~-XZ@+BC@QJS?{-$bQayHR&s$7wik`=@f&
z&-`qfcKpd}etIEg99)(C;AJ$L4Vt$PWs><(GMXqt6pjFS^D0V0IqS%25~hmV*A4E5
z>kgV*^ZDMv?zXqLzrWb_<_C{jDDOUAEL``_{RdBu250ekB0u0=VFIUyvRlSqIiBmn
z`(N}YNh}kd3+8Z}gf2d2ZrvKpYtt~Z8~`1tl@&qLlA>xw=2_gsC2*(cCn>5gcyxK}
z1|3lkbJE4i=+O?=QCMQ|ddxE%?4KdV9-)_&U8GiA9u4xfm{H$tTuXEt)GA;V_?H#n
z?}LZLzHR(cd-dr+rmg_+HB>7@ng28}$1}cd{8D?gz=Wp4YpO6;458_$_YAIW{8D>O
zCt)rh!t^Z64MnKl5#LjA5^e2mZWXW!6cwoI$0ncuz2D#eizNGG6|f5YR|<$)x8LpH
zmCV_?@^XCEdPwh(*ci9eUQv*l<5(5=DBeO+hBl82@NMIl+M@<${|G1<Y-SbsqYC^4
DI~)p>

literal 0
HcmV?d00001

diff --git a/plotly/.DS_Store b/plotly/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..a30cea8f4296fce58e3c1263ac4d5ec09b07f2dc
GIT binary patch
literal 6148
zcmeHKu}T9$5PcI<1T0J;V!2-+SXc-a>k*4IHu?dYL{NyH#7kj!zv7qbo7qt=c&L?#
z%)rju+nqPN_uzJK07$i790FqiBQ{0RPLJtu@6^D9w}@gnZgGzrG`PdOC(&OV(!KBE
z6f5qzL3jUCJm4H_zR@F|aiD&>tmm_3JtK#L$qVuL)y>8<&kEO!f5Nx?!5%qPhreT-
zh8b#HvVFb!5!ojlHXp-6flwe62n9lcA1J^(TWz#mFnlNw3WNe53h4Qe*c7v4ThNXU
zIx7K)Lk^p<ueF47l4Evk3vz}gg-R?`@e)G{o#V;lvSVAY&>>!Yh_C!!yojyN{K>*0
zxnTHEAQaeCKx<#xSnvNcelop9zJ-Jf1ww)Us(=h97n6!_=XdL;_td*Kv0bsLX<Vxv
n8v7eR0esMNWZx#se9}JSvSV9Nv*@_diSZ*~f`khNenEjZrr|_=

literal 0
HcmV?d00001

diff --git a/plotly/ArithmeticInNumpy.py b/plotly/ArithmeticInNumpy.py
new file mode 100644
index 0000000..1dd1186
--- /dev/null
+++ b/plotly/ArithmeticInNumpy.py
@@ -0,0 +1,164 @@
+import marimo
+
+__generated_with = "0.12.9"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Notebook 2: NumPy for Operations and Arrays**
+
+        In this notebook, you'll gain an understanding of NumPy's usage for basic arithmetic operations. Then, we will explore how to create matrices and how to apply these operations to them.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    # If you haven't already, make sure to first install NumPy by running the command 'pip install numpy'
+
+    import numpy as np
+    return (np,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Basic Arithmetic**
+
+        Let's begin with some basic operations. Run the cells below to see how NumPy can be used for operations and functions.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    print(np.add(10,5))
+    print(np.subtract(10,5))
+    print(np.multiply(10,5))
+    print(np.divide(10,5))
+    return
+
+
+@app.cell
+def _(np):
+    # It can also be used for power.
+    print(np.power(2,3))
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Numpy can also be used for mathematical constants.""")
+    return
+
+
+@app.cell
+def _(np):
+    print(np.pi)
+    print(np.sqrt(2))
+    print(np.log(10))
+    print(np.cos(np.pi / 2))
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        Below, try writing out this function with as few parenthesis as possible: 
+
+        $$
+        5 + \log(4) \times \pi^6 - \frac{5}{4}
+        $$
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    # Your code here!
+    # Hint: consider the order of PEMDAS.
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        Now that you've seen how NumPy handles math, it's time to understand how arrays work.
+
+        Arrays are basically 'super-powered' lists - they're more efficient, easier to use for math, and down the line, much better for handling big data.
+
+        Let's bgin with a 1D array.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    # In python, you might create a list like this.
+    lst = [1,2,3,4,5]
+    lst
+    return (lst,)
+
+
+@app.cell
+def _(lst, np):
+    # Using NumPy, we can create an array from this list. 
+    arr = np.array(lst)
+    return (arr,)
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Let's learn more about the characteristics of arrays.""")
+    return
+
+
+@app.cell
+def _(arr):
+    print("Type: ", type(arr))
+    print("Shape: ", arr.shape)
+    print("Size: ", arr.size)
+    print("Data type: ", arr.dtype)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        What does this mean?
+
+        **Type** tells us the type of the array itself - it belongs to the class array.
+        **shape** tells us the structure - here, it's a flat row with 5 values, or 5x1.
+        **size** tells us the total amount of elements in the array. Lastly, in this case, **data type** tells us the data type of the entries within the array, in this case usually int64 or float64 (numbers).
+
+        Below, try creating a 1D array with 10 numbers. Try printing its shape, size, and type.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    # Your code here!
+    return
+
+
+if __name__ == "__main__":
+    app.run()
diff --git a/plotly/ArraysInNumpy.py b/plotly/ArraysInNumpy.py
new file mode 100644
index 0000000..8ad8ad3
--- /dev/null
+++ b/plotly/ArraysInNumpy.py
@@ -0,0 +1,277 @@
+import marimo
+
+__generated_with = "0.12.9"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Accessing and Transforming 2D Arrays**
+
+        In this notebook, we'll focus on accessing individual values and slices of arrays, understanding how to work with 2D arrays, and learn the difference between copying and viewing arays.
+
+        Let's get started!
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Indexing in 1D Arrays**
+
+        Let's begin with a simple 1D array and learn how to grab values based on their index position
+
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import numpy as np
+    return (np,)
+
+
+@app.cell
+def _(np):
+    # Run the code below. 
+    arr = np.array([10, 20, 30, 40, 50])
+    arr
+    return (arr,)
+
+
+@app.cell
+def _(arr):
+    # The following code indexes the first value and the last value of the array.
+    print(arr[0])
+    print(arr[-1])
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Simple enough - now let's look at slicing multiple values from the arrays.""")
+    return
+
+
+@app.cell
+def _(arr):
+    print(arr[:3]) # Gives us the first 3 values
+    print(arr[1:4]) # Gives us the values from position 1-3
+    print(arr[::2]) # Gives us every other value
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        In general, you can use the format *[start:stop:step]*.
+
+        Below, try to slice the array to only include the following values.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+
+    print(arr1["""Your code here!"""]) # Every third value, starting at position 0
+    print(arr1["""Your code here!"""]) # The last two values
+    print(arr1["""Your code here!"""]) # Values from index position 4 to 7
+    return (arr1,)
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Let's move on to indexing in 2D arrays. Take a look at the matrix (2D array) below.""")
+    return
+
+
+@app.cell
+def _(np):
+    matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    matrix
+    return (matrix,)
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Looks confusing at first? Remember, a matrix is essentially just many lists within a list. By cleverly slicing the matrix, we can access the values we need! Run the code below to see.""")
+    return
+
+
+@app.cell
+def _(matrix):
+    print("Top left:", matrix[0, 0]) 
+    print("Middle:", matrix[1, 1])  
+    print("Last column:", matrix[:, 2]) # ":" means 'take all' - helpful for grabbing entire rows or columns
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Very similar to 1D slicing. Below, try to slice the matrices yourself!""")
+    return
+
+
+@app.cell
+def _():
+    matrix1 = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
+
+    print(matrix1["""Your code here!"""]) # Grab the last element in the last row
+    print(matrix1["""Your code here!"""]) # Grab the first element in the second column
+    print(matrix1["""Your code here!"""]) # Grab the first and third elements in the second row
+    return (matrix1,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        Great! Now that we understand how to access certain elements, lets see how we can work with arrays even more.
+
+        **Reshaping Arrays**
+
+        Reshaping allows ou to change the layout of an array without changing the data itself. This is really useful when you need your data in a different format - for example, turning a long list into a grid.
+
+        Run the code below to see an example of reshaping a 1D array into a 2D array.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    arr2 = np.arange(12)
+    print("Original: ", arr2)
+
+    reshaped = arr2.reshape((3, 4))
+    print("Reshaped: \n", reshaped)
+
+    return arr2, reshaped
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        Notice how we turned a long, horizontal list into a 3 x 4 grid, or matrix. Recall that the first number, 3, represents the number of rows, while the second number, 4, represents the number of columns.
+
+        You can also use -1 to let NumPy figure out the size for you. This is handy when you know how many rows you want, but are not sure how many columns.
+        """
+    )
+    return
+
+
+@app.cell
+def _(arr2):
+    reshaped_auto = arr2.reshape((4, -1))
+    reshaped_auto
+    return (reshaped_auto,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Flattening Arrays**
+
+        On the contrary, flattening turns our multidimensional array into a single line, or 1D array. This comes to be in handy when, for example, feeding data into a machine learning model, saving or exporting data, or just attemping to simplify things. 
+
+        Check out the example below.
+        """
+    )
+    return
+
+
+@app.cell
+def _(matrix, np):
+    matrix2 = np.array([[1, 2, 3], [4, 5, 6]])
+    print("Original:\n", matrix)
+
+    flat = matrix2.flatten()
+    print("Flattened:", flat)
+    return flat, matrix2
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Helpful tip: *.flatten()* will always give you a copy of the data. """)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Transposing Arrays**
+
+        You might remember transposing if you took a linear algebra class. Here, transposing means 'flipping' the matrix - the rows become columns, and the columns become rows. 
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    arr3 = np.array([[1, 2, 3], [4, 5, 6]])
+    print("Original:\n", arr3)
+
+    transposed = arr3.T
+    print("Transposed:\n", transposed)
+
+    return arr3, transposed
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""You can use *.T* or *.transpose()* interchangebly.""")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Let's do some practice below!""")
+    return
+
+
+app._unparsable_cell(
+    r"""
+    # First, create an array with numbers 1 to 16
+    arr4 = np.arange()
+
+    # Next, reshape it to 4x4
+    arr4 = 
+
+    # Transpose the matrix
+    arr4 = 
+
+    # Lastly, flatten the result
+    arr4 = 
+    """,
+    name="_"
+)
+
+
+@app.cell
+def _():
+    # Challenge - can you transform this matrix back into the original?
+    return
+
+
+if __name__ == "__main__":
+    app.run()
diff --git a/plotly/IntroToNumpy.py b/plotly/IntroToNumpy.py
new file mode 100644
index 0000000..e0fb689
--- /dev/null
+++ b/plotly/IntroToNumpy.py
@@ -0,0 +1,316 @@
+import marimo
+
+__generated_with = "0.12.9"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""**Notebook 1: Introduction to NumPy**""")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **What is NumPy?**
+
+        NumPy stands for *numerical python* and is one of the foundational libraries for numerical computing and operations in Python! It's efficient and powerful, and introduces users to working with datasets, simulations, image processing, and more! In fact, NumPy introduced the **array**, a fundamental data structure in Python.
+
+        Let's begin. In your terminal, make sure to activate your environment and install NumPy. You can do this by typing:
+
+        *pip install NumPy*
+
+        **Great! In this notebook, we'll:**
+
+        - Learn what NumPy is and why it's widely used.
+        - See some cool demos showing off what NumPy can do.
+        - Run real-world examples.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+@app.cell
+def _():
+    # Let's start by importing numpy.
+
+    import numpy as np
+    return (np,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Simulate 1 Million Dice Rolls**
+
+        Let's start with a simple but powerful example of NumPy. Using the function *np.random.randint*, we can simulate the roll of a die one million times. In regular Python, we'd probably need a huge loop - but with NumPy, we can do it in one line. 
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    rolls = np.random.randint(1, 7, size = 1000000)
+    return (rolls,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **What's happening here?**
+
+        The code above creates *one million random integers* between 1 and 6 (inclusive), simulating the rolling of a regular 6-sided die a million times. **Rolls** is now a NumPy array holding all those results!
+        """
+    )
+    return
+
+
+@app.cell
+def _(np, rolls):
+    # Let's analyze the dice rolls. 
+
+    print("Average roll: ", np.mean(rolls))
+    print("Standard deviation: ", np.std(rolls))
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        That was a simple example. Let's look at something a little more in depth, using another library, **Matplotlib**. 
+
+        **Gradient Heatmap**
+
+        Here, we'll create a colorful 2D graph of a math function using NumPy and Matplotlib!
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import matplotlib.pyplot as plt
+    return (plt,)
+
+
+@app.cell
+def _(np):
+    x = np.linspace(-3, 3, 100)
+    y = np.linspace(-3, 3, 100)
+
+    X, Y = np.meshgrid(x, y)
+    Z = np.sin(X ** 2 + Y ** 2)
+    return X, Y, Z, x, y
+
+
+@app.cell
+def _(Z, plt):
+    plt.imshow(Z, cmap='Accent', extent=(-3, 3, -3, 3))
+    plt.title("Sinusoidal Gradient")
+    plt.colorbar()
+    plt.show()
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **What's going on here?**
+
+        Well, we used *np.linspace()*, which allowed us to create 100 values between -3 and 3. The function *np.meshgrid()* allowed us to turn x and y into 2D coordinates and plot them on a graph. Lastly, *np.sin()* applied a math function to every grid point. *Plt.imshow()*, from the Matplotlib library, allows us to visualize it. 
+
+        It's understanding if this is confusing! But this just shows us how NumPy can be used in combination with other libraries to create pretty cool visualizations.
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Simulating Human Height Data**
+
+        We can also use numpy to analyze data. For example, let's pretend we're studying a sample of 10,000 people and we want to analyze their heights.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    heights = np.random.normal(loc = 170, scale = 10, size = 10000)
+    return (heights,)
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **What's happening here?**
+
+        *np.random.normal()* generates for us random values from a normal distribution. We pass in certain information, like *loc = 170* (The average height is 170 cm), *scale = 10* (The standard deviation is 10 cm) and *size = 10000* (We are simulating 10,000 individuals).
+        """
+    )
+    return
+
+
+@app.cell
+def _(heights, plt):
+    # Just like in the last example, let's visualize the data. 
+
+    plt.hist(heights, bins=50, color='skyblue', edgecolor='black')
+    plt.title("Simulated Human Heights")
+    plt.xlabel("Height (cm)")
+    plt.ylabel("Number of People")
+    plt.show()
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""A bell curve - normally distributed, and most people are near the average.""")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Predicting Loan Payments**
+
+        Let’s say you want to model how much someone would pay per month for a small loan — similar to what a banker or budgeting app might do. This example shows us how NumPy can do financial math!
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        We'll use the basic loan formula:
+
+        $$
+        \text{Monthly Payment} = \frac{P \cdot r}{1 - (1 + r)^{-n}}
+        $$
+
+        Where P is the loan amount, r is the monthly interest rate, and n is the number of monthly payments.
+        """
+    )
+    return
+
+
+@app.cell
+def monthly_payment():
+    # First, let's create a function to define the loan formula. 
+
+    def monthly_payment(principal, annual_rate, months):
+        r = annual_rate / 12  # Convert to monthly interest rate
+        payment = (principal * r) / (1 - (1 + r) ** -months)
+        return payment
+
+    return (monthly_payment,)
+
+
+@app.cell
+def _(monthly_payment):
+    # Now we can experiment!
+
+    loan = 10000
+    rate = 0.05
+    months = 36
+
+    payment = monthly_payment(loan, rate, months)
+    print(f"Monthly payment: ${payment: .2f}")
+    return loan, months, payment, rate
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Seems pretty simple - now let's see if we can calculate payments for many loan amounts at once.""")
+    return
+
+
+@app.cell
+def _(loan, monthly_payment, np):
+    loan_amounts = np.arange(1_000, 11_000, 1_000)
+    new_rate = 0.05
+    new_months = 36
+
+    new_payments = monthly_payment(loan_amounts, new_rate, new_months)
+
+    for loan_item, pmt in zip(loan_amounts, new_payments):
+        print(f"Loan: ${loan}, Monthly Payment: ${pmt:.2f}")
+    return loan_amounts, loan_item, new_months, new_payments, new_rate, pmt
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Because loan_ammounts is a NumPy array, the function calculates all our payments at once! Let's take a look at how to plot it.""")
+    return
+
+
+@app.cell
+def _(loan_amounts, new_payments, plt):
+    plt.plot(loan_amounts, new_payments, marker='o')
+    plt.title("Loan Amount vs. Monthly Payment")
+    plt.xlabel("Loan Amount")
+    plt.ylabel("Monthly Payment")
+    plt.grid(True)
+    plt.show()
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""The graph shows us a straight line - as the loan increases, so does the payment. With NumPy, we did all the math with just one function!""")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Bonus Challenge**
+
+        Can you calculate how much interest you would pay in total over the entire loan?
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    # Your code here!
+    # Hint: What function can you use to add everything together?
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        **Notebook Summary**
+
+        In this notebook, we explored some of the exciting things NumPy can do — even if you're new to coding.
+        """
+    )
+    return
+
+
+if __name__ == "__main__":
+    app.run()

From a166d1c2e91d3eb2f1d44502381e9e263e726410 Mon Sep 17 00:00:00 2001
From: Anisha Kalgi <k_anisha@icloud.com>
Date: Mon, 19 May 2025 15:28:18 -0700
Subject: [PATCH 2/4] update

---
 .DS_Store                        | Bin 6148 -> 8196 bytes
 calculus_for_ML/RatesOfChange.py | 232 +++++++++++++++++++++++++++++++
 2 files changed, 232 insertions(+)
 create mode 100644 calculus_for_ML/RatesOfChange.py

diff --git a/.DS_Store b/.DS_Store
index 469bcd3edac83e85f2ae623ca3146a225f9d4d0a..971bd36c85e0d085e55838a90a110a3168ee5c1f 100644
GIT binary patch
delta 517
zcmZoMXmOBWU|?W$DortDU;r^WfEYvza8E20o2aMAD84aZH}hr%jz7$c**Q2SHn1>?
zPv&8Xjpb)ZW=Len0g|OavXr5iA)X<PA)lcLNc%GQc;@6MC*|ZPfs6uT3!o(;|G@yr
zV_+bld-6S2Ic5%Sj>-R7BV{?`1thAgP0UPm6ih5kYIPK<EsYF-Y-6+9TF%L(YzFlN
zOv_0(3{K9^EdbjLAqeQm&3AEux}IZMXHW9yx5pfDySg6c>D>Gj612f|6=aa=yt3e;
zyqx^JbfA+Mfp~K!%RJ_d4fhxYnIXQD;0DsJph(;-$nl+dGQWuDWPctG4xnOC{4z|A
Q=b66wE}ItP#)jLB09~VV@&Et;

delta 104
zcmZp1XfcprU|?W$DortDU=RQ@Ie-{Mvv5r;6q~50$SANeU^g?Pz+@hQ*v;KS^OzU2
qb8rYU162Tl05_0u1u5QG_?>w&zl<kHD+3e67?8;fo8x)rFarR3=MXpm

diff --git a/calculus_for_ML/RatesOfChange.py b/calculus_for_ML/RatesOfChange.py
new file mode 100644
index 0000000..1d7c093
--- /dev/null
+++ b/calculus_for_ML/RatesOfChange.py
@@ -0,0 +1,232 @@
+import marimo
+
+__generated_with = "0.12.9"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from sympy import symbols
+    from sympy import diff
+    return diff, mo, np, plt, symbols
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        In this notebook, we'll learn about rates of change in Machine Learning. 
+
+        In simple terms, the rate of change measures how one quantity changes as we adjust its inputs or parameters. The rate of change can represent how a model's output changes as we adjust the input or parameters. 
+
+        In calculus, the rate of change of a function is given by calculating the derivative at a certain point. So, if f(x) is a function, then f'(x) is the rate of change. 
+
+        In the context of Machine Learning, rates of change are especially useful when working with optimization problems - for example, minimizing a loss function, or using gradient descent to try and find optimal parameters and minimize error.
+
+        Let's get into rates of change!
+        """
+    )
+    return
+
+
+@app.cell
+def _(np, plt):
+    # First, let's start by definiting a simple function. 
+
+    def f(x):
+        return x ** 2
+
+    # Now, we can plot the function.abs
+
+    x = np.linspace(-10, 10, 500)
+    y = f(x)
+
+    plt.plot(x, y, label=r'$f(x) = x^2$')
+    plt.title('Graph of f(x) = x^2')
+    plt.xlabel('x')
+    plt.ylabel('f(x)')
+    plt.axhline(0, color='black',linewidth=0.5)
+    plt.axvline(0, color='black',linewidth=0.5)
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+    return f, x, y
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Our graph is a parabola. Now, let's find the derivative.""")
+    return
+
+
+@app.cell
+def _(plt, x):
+    def deriv_f(x):
+        return 2 * x
+
+    deriv_y = deriv_f(x)
+
+    plt.plot(x, deriv_y, label=r"$f'(x) = 2x$", color='red')
+    plt.title('Derivative of f(x) = x^2')
+    plt.xlabel('x')
+    plt.ylabel("f'(x)")
+    plt.axhline(0, color='black',linewidth=0.5)
+    plt.axvline(0, color='black',linewidth=0.5)
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+    return deriv_f, deriv_y
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""We can see that the rate of change, or the slope, is positive when x is also positive. This should all be review from high school math! :)""")
+    return
+
+
+@app.cell
+def _(diff, symbols):
+    # Now, we'll use SymPy, a library for symbolic math functions in Python.
+    # Here we've created a function and then found the derivative of it.
+
+    x_sym = symbols('x')
+    f_sym = x_sym ** 3 + 4 * x_sym + 5
+
+    f_deriv_sym = diff(f_sym, x_sym)
+    f_deriv_sym
+    return f_deriv_sym, f_sym, x_sym
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Now, let's get into gradient descent. Below is an example on a quadratic function.""")
+    return
+
+
+@app.cell
+def _(deriv_f, f, np, plt):
+    # Our parameters below
+
+    learning_rate = 0.1
+    initial = 8
+    iterations = 20
+
+    current = initial
+    history = [current]
+
+    for i in range(iterations):
+        grad = deriv_f(current)
+        current = current - learning_rate * grad
+        history.append(current)
+
+    x_vals = np.linspace(-10, 10, 400)
+    y_vals = f(x_vals)
+
+    plt.plot(x_vals, y_vals, label=r'$f(x) = x^2$')
+    plt.scatter(history, f(np.array(history)), color='red', label='Gradient Descent')
+    plt.title('Gradient Descent on f(x) = x^2')
+    plt.xlabel('x')
+    plt.ylabel('f(x)')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+    return (
+        current,
+        grad,
+        history,
+        i,
+        initial,
+        iterations,
+        learning_rate,
+        x_vals,
+        y_vals,
+    )
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        What's happening here?
+
+        At a high level, gradient descent is essentially taking the partial derivative at each point in the function, until it converges to a minimum. Because our f(x) is a 'nice' function (i.e., there are no annoying curves, saddle points, or other minima/maxima), we are guaranteed that our gradient descent can find the minimum. 
+
+        What is the minimum in this case? It's the **point on the function where the rate of change is closest to 0**.
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        Now, we can get into some applications of rates of change to fully understand the concept.
+
+        First, let's look at kinematics. We know that position, velocity, and acceleration are related, but how? Interestingly, **the derivative of position is velocity, and the derivative of velocity is acceleration!**
+        """
+    )
+    return
+
+
+@app.cell
+def _(np, plt):
+    # Let's say we have a position function of an object that is 5t^2, where t is time.
+
+    time = np.linspace(0, 10, 100)
+
+    position = 5 * time**2
+
+    velocity = 10 * time
+
+    acceleration = np.full_like(time, 10)
+
+    plt.plot(time, position, label='Position (s(t) = 5t^2)')
+    plt.plot(time, velocity, label='Velocity (v(t) = 10t)', linestyle='--')
+    plt.plot(time, acceleration, label='Acceleration (a(t) = 10)', linestyle=':')
+    plt.title('Position, Velocity, and Acceleration')
+    plt.xlabel('Time (t)')
+    plt.ylabel('Position / Velocity / Acceleration')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+    return acceleration, position, time, velocity
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Here, we can see that the orange line, velocity, represents the rate of change of position at the exact time t = 2 seconds. When we look at the green line, it tell us the rate of change of velocity  at that exact same point in time!""")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        We can use another example in economics. In economics, there is a term known as 'Price Sensitivity,' wjich essentially measures the rate of change in the quantity demanded or supplied of a good. The price elasticity is given by the formula:
+
+        Elasticity = % change in qty. demanded / % change in price
+
+        Using derivatives, we would say:
+
+        Elasticity = the rate of change of demand with respect to price * (price / quantity)
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    return
+
+
+@app.cell
+def _():
+    return
+
+
+if __name__ == "__main__":
+    app.run()

From 84a4fc37565b9cd59ff6953cd4fd50632cd2f377 Mon Sep 17 00:00:00 2001
From: Anisha Kalgi <k_anisha@icloud.com>
Date: Mon, 26 May 2025 21:20:50 -0700
Subject: [PATCH 3/4] Rates of Change

---
 .DS_Store                 | Bin 8196 -> 8196 bytes
 calculus_for_ML/README.md |  21 +++++++++++++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 calculus_for_ML/README.md

diff --git a/.DS_Store b/.DS_Store
index 971bd36c85e0d085e55838a90a110a3168ee5c1f..02a0c9baa575373b3d65578e3bd96c77b296e5d0 100644
GIT binary patch
delta 144
zcmZp1XmOa}&nUSuU^hRb<YpcLW>#J{h609sh8%`Oh9ZXINg{HSp9mx|TNoQn_7rrH
gM3F2DF3QWv&r4@uU|`(LBg)ORnO%Z|0s}ah0P#s8Gynhq

delta 40
qcmZp1XmOa}&nUhzU^hRb_+}mfX4cLBMLC!zHhkF3F2MogyafOYa}Bxx

diff --git a/calculus_for_ML/README.md b/calculus_for_ML/README.md
new file mode 100644
index 0000000..3092f19
--- /dev/null
+++ b/calculus_for_ML/README.md
@@ -0,0 +1,21 @@
+# Learn Calculus for Machine Learning
+
+_🚧 This collection is a work in progress. Please help us add notebooks!_
+
+This collection of marimo notebooks is designed to teach you the basics of calculus for machine learning.
+
+**Help us build this course! ⚒️**
+
+We're seeking contributors to help us build these notebooks. Every contributor will be acknowledged as an author in this README and in their contributed notebooks. Head over to the [tracking issue](https://github.com/marimo-team/learn/issues/58) to sign up for a planned notebook or propose your own.
+
+**Running notebooks.** To run a notebook locally, use
+
+```bash
+uvx marimo edit <file_url>
+```
+
+You can also open notebooks in our online playground by appending marimo.app/ to a notebook's URL.
+
+**Thanks to all our notebook authors!**
+
+[Anisha Kalgi](https://github.com/k-anisha)
\ No newline at end of file

From f27a7ff3d24ed5de42f8ef41e52f60115c72d434 Mon Sep 17 00:00:00 2001
From: Anisha Kalgi <k_anisha@icloud.com>
Date: Wed, 28 May 2025 20:44:04 -0700
Subject: [PATCH 4/4] adding files

---
 calculus_for_ML/RatesOfChange.py |   2 +-
 plotly/.DS_Store                 | Bin 6148 -> 0 bytes
 plotly/ArithmeticInNumpy.py      | 164 ----------------
 plotly/ArraysInNumpy.py          | 277 ---------------------------
 plotly/IntroToNumpy.py           | 316 -------------------------------
 5 files changed, 1 insertion(+), 758 deletions(-)
 delete mode 100644 plotly/.DS_Store
 delete mode 100644 plotly/ArithmeticInNumpy.py
 delete mode 100644 plotly/ArraysInNumpy.py
 delete mode 100644 plotly/IntroToNumpy.py

diff --git a/calculus_for_ML/RatesOfChange.py b/calculus_for_ML/RatesOfChange.py
index 1d7c093..77e2c27 100644
--- a/calculus_for_ML/RatesOfChange.py
+++ b/calculus_for_ML/RatesOfChange.py
@@ -1,6 +1,6 @@
 import marimo
 
-__generated_with = "0.12.9"
+__generated_with = "0.13.1"
 app = marimo.App(width="medium")
 
 
diff --git a/plotly/.DS_Store b/plotly/.DS_Store
deleted file mode 100644
index a30cea8f4296fce58e3c1263ac4d5ec09b07f2dc..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKu}T9$5PcI<1T0J;V!2-+SXc-a>k*4IHu?dYL{NyH#7kj!zv7qbo7qt=c&L?#
z%)rju+nqPN_uzJK07$i790FqiBQ{0RPLJtu@6^D9w}@gnZgGzrG`PdOC(&OV(!KBE
z6f5qzL3jUCJm4H_zR@F|aiD&>tmm_3JtK#L$qVuL)y>8<&kEO!f5Nx?!5%qPhreT-
zh8b#HvVFb!5!ojlHXp-6flwe62n9lcA1J^(TWz#mFnlNw3WNe53h4Qe*c7v4ThNXU
zIx7K)Lk^p<ueF47l4Evk3vz}gg-R?`@e)G{o#V;lvSVAY&>>!Yh_C!!yojyN{K>*0
zxnTHEAQaeCKx<#xSnvNcelop9zJ-Jf1ww)Us(=h97n6!_=XdL;_td*Kv0bsLX<Vxv
n8v7eR0esMNWZx#se9}JSvSV9Nv*@_diSZ*~f`khNenEjZrr|_=

diff --git a/plotly/ArithmeticInNumpy.py b/plotly/ArithmeticInNumpy.py
deleted file mode 100644
index 1dd1186..0000000
--- a/plotly/ArithmeticInNumpy.py
+++ /dev/null
@@ -1,164 +0,0 @@
-import marimo
-
-__generated_with = "0.12.9"
-app = marimo.App(width="medium")
-
-
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Notebook 2: NumPy for Operations and Arrays**
-
-        In this notebook, you'll gain an understanding of NumPy's usage for basic arithmetic operations. Then, we will explore how to create matrices and how to apply these operations to them.
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    # If you haven't already, make sure to first install NumPy by running the command 'pip install numpy'
-
-    import numpy as np
-    return (np,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Basic Arithmetic**
-
-        Let's begin with some basic operations. Run the cells below to see how NumPy can be used for operations and functions.
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    print(np.add(10,5))
-    print(np.subtract(10,5))
-    print(np.multiply(10,5))
-    print(np.divide(10,5))
-    return
-
-
-@app.cell
-def _(np):
-    # It can also be used for power.
-    print(np.power(2,3))
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Numpy can also be used for mathematical constants.""")
-    return
-
-
-@app.cell
-def _(np):
-    print(np.pi)
-    print(np.sqrt(2))
-    print(np.log(10))
-    print(np.cos(np.pi / 2))
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        Below, try writing out this function with as few parenthesis as possible: 
-
-        $$
-        5 + \log(4) \times \pi^6 - \frac{5}{4}
-        $$
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    # Your code here!
-    # Hint: consider the order of PEMDAS.
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        Now that you've seen how NumPy handles math, it's time to understand how arrays work.
-
-        Arrays are basically 'super-powered' lists - they're more efficient, easier to use for math, and down the line, much better for handling big data.
-
-        Let's bgin with a 1D array.
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    # In python, you might create a list like this.
-    lst = [1,2,3,4,5]
-    lst
-    return (lst,)
-
-
-@app.cell
-def _(lst, np):
-    # Using NumPy, we can create an array from this list. 
-    arr = np.array(lst)
-    return (arr,)
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Let's learn more about the characteristics of arrays.""")
-    return
-
-
-@app.cell
-def _(arr):
-    print("Type: ", type(arr))
-    print("Shape: ", arr.shape)
-    print("Size: ", arr.size)
-    print("Data type: ", arr.dtype)
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        What does this mean?
-
-        **Type** tells us the type of the array itself - it belongs to the class array.
-        **shape** tells us the structure - here, it's a flat row with 5 values, or 5x1.
-        **size** tells us the total amount of elements in the array. Lastly, in this case, **data type** tells us the data type of the entries within the array, in this case usually int64 or float64 (numbers).
-
-        Below, try creating a 1D array with 10 numbers. Try printing its shape, size, and type.
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    # Your code here!
-    return
-
-
-if __name__ == "__main__":
-    app.run()
diff --git a/plotly/ArraysInNumpy.py b/plotly/ArraysInNumpy.py
deleted file mode 100644
index 8ad8ad3..0000000
--- a/plotly/ArraysInNumpy.py
+++ /dev/null
@@ -1,277 +0,0 @@
-import marimo
-
-__generated_with = "0.12.9"
-app = marimo.App(width="medium")
-
-
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Accessing and Transforming 2D Arrays**
-
-        In this notebook, we'll focus on accessing individual values and slices of arrays, understanding how to work with 2D arrays, and learn the difference between copying and viewing arays.
-
-        Let's get started!
-        """
-    )
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Indexing in 1D Arrays**
-
-        Let's begin with a simple 1D array and learn how to grab values based on their index position
-
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    import numpy as np
-    return (np,)
-
-
-@app.cell
-def _(np):
-    # Run the code below. 
-    arr = np.array([10, 20, 30, 40, 50])
-    arr
-    return (arr,)
-
-
-@app.cell
-def _(arr):
-    # The following code indexes the first value and the last value of the array.
-    print(arr[0])
-    print(arr[-1])
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Simple enough - now let's look at slicing multiple values from the arrays.""")
-    return
-
-
-@app.cell
-def _(arr):
-    print(arr[:3]) # Gives us the first 3 values
-    print(arr[1:4]) # Gives us the values from position 1-3
-    print(arr[::2]) # Gives us every other value
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        In general, you can use the format *[start:stop:step]*.
-
-        Below, try to slice the array to only include the following values.
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-
-    print(arr1["""Your code here!"""]) # Every third value, starting at position 0
-    print(arr1["""Your code here!"""]) # The last two values
-    print(arr1["""Your code here!"""]) # Values from index position 4 to 7
-    return (arr1,)
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Let's move on to indexing in 2D arrays. Take a look at the matrix (2D array) below.""")
-    return
-
-
-@app.cell
-def _(np):
-    matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    matrix
-    return (matrix,)
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Looks confusing at first? Remember, a matrix is essentially just many lists within a list. By cleverly slicing the matrix, we can access the values we need! Run the code below to see.""")
-    return
-
-
-@app.cell
-def _(matrix):
-    print("Top left:", matrix[0, 0]) 
-    print("Middle:", matrix[1, 1])  
-    print("Last column:", matrix[:, 2]) # ":" means 'take all' - helpful for grabbing entire rows or columns
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Very similar to 1D slicing. Below, try to slice the matrices yourself!""")
-    return
-
-
-@app.cell
-def _():
-    matrix1 = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
-
-    print(matrix1["""Your code here!"""]) # Grab the last element in the last row
-    print(matrix1["""Your code here!"""]) # Grab the first element in the second column
-    print(matrix1["""Your code here!"""]) # Grab the first and third elements in the second row
-    return (matrix1,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        Great! Now that we understand how to access certain elements, lets see how we can work with arrays even more.
-
-        **Reshaping Arrays**
-
-        Reshaping allows ou to change the layout of an array without changing the data itself. This is really useful when you need your data in a different format - for example, turning a long list into a grid.
-
-        Run the code below to see an example of reshaping a 1D array into a 2D array.
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    arr2 = np.arange(12)
-    print("Original: ", arr2)
-
-    reshaped = arr2.reshape((3, 4))
-    print("Reshaped: \n", reshaped)
-
-    return arr2, reshaped
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        Notice how we turned a long, horizontal list into a 3 x 4 grid, or matrix. Recall that the first number, 3, represents the number of rows, while the second number, 4, represents the number of columns.
-
-        You can also use -1 to let NumPy figure out the size for you. This is handy when you know how many rows you want, but are not sure how many columns.
-        """
-    )
-    return
-
-
-@app.cell
-def _(arr2):
-    reshaped_auto = arr2.reshape((4, -1))
-    reshaped_auto
-    return (reshaped_auto,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Flattening Arrays**
-
-        On the contrary, flattening turns our multidimensional array into a single line, or 1D array. This comes to be in handy when, for example, feeding data into a machine learning model, saving or exporting data, or just attemping to simplify things. 
-
-        Check out the example below.
-        """
-    )
-    return
-
-
-@app.cell
-def _(matrix, np):
-    matrix2 = np.array([[1, 2, 3], [4, 5, 6]])
-    print("Original:\n", matrix)
-
-    flat = matrix2.flatten()
-    print("Flattened:", flat)
-    return flat, matrix2
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Helpful tip: *.flatten()* will always give you a copy of the data. """)
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Transposing Arrays**
-
-        You might remember transposing if you took a linear algebra class. Here, transposing means 'flipping' the matrix - the rows become columns, and the columns become rows. 
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    arr3 = np.array([[1, 2, 3], [4, 5, 6]])
-    print("Original:\n", arr3)
-
-    transposed = arr3.T
-    print("Transposed:\n", transposed)
-
-    return arr3, transposed
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""You can use *.T* or *.transpose()* interchangebly.""")
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Let's do some practice below!""")
-    return
-
-
-app._unparsable_cell(
-    r"""
-    # First, create an array with numbers 1 to 16
-    arr4 = np.arange()
-
-    # Next, reshape it to 4x4
-    arr4 = 
-
-    # Transpose the matrix
-    arr4 = 
-
-    # Lastly, flatten the result
-    arr4 = 
-    """,
-    name="_"
-)
-
-
-@app.cell
-def _():
-    # Challenge - can you transform this matrix back into the original?
-    return
-
-
-if __name__ == "__main__":
-    app.run()
diff --git a/plotly/IntroToNumpy.py b/plotly/IntroToNumpy.py
deleted file mode 100644
index e0fb689..0000000
--- a/plotly/IntroToNumpy.py
+++ /dev/null
@@ -1,316 +0,0 @@
-import marimo
-
-__generated_with = "0.12.9"
-app = marimo.App(width="medium")
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""**Notebook 1: Introduction to NumPy**""")
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **What is NumPy?**
-
-        NumPy stands for *numerical python* and is one of the foundational libraries for numerical computing and operations in Python! It's efficient and powerful, and introduces users to working with datasets, simulations, image processing, and more! In fact, NumPy introduced the **array**, a fundamental data structure in Python.
-
-        Let's begin. In your terminal, make sure to activate your environment and install NumPy. You can do this by typing:
-
-        *pip install NumPy*
-
-        **Great! In this notebook, we'll:**
-
-        - Learn what NumPy is and why it's widely used.
-        - See some cool demos showing off what NumPy can do.
-        - Run real-world examples.
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
-@app.cell
-def _():
-    # Let's start by importing numpy.
-
-    import numpy as np
-    return (np,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Simulate 1 Million Dice Rolls**
-
-        Let's start with a simple but powerful example of NumPy. Using the function *np.random.randint*, we can simulate the roll of a die one million times. In regular Python, we'd probably need a huge loop - but with NumPy, we can do it in one line. 
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    rolls = np.random.randint(1, 7, size = 1000000)
-    return (rolls,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **What's happening here?**
-
-        The code above creates *one million random integers* between 1 and 6 (inclusive), simulating the rolling of a regular 6-sided die a million times. **Rolls** is now a NumPy array holding all those results!
-        """
-    )
-    return
-
-
-@app.cell
-def _(np, rolls):
-    # Let's analyze the dice rolls. 
-
-    print("Average roll: ", np.mean(rolls))
-    print("Standard deviation: ", np.std(rolls))
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        That was a simple example. Let's look at something a little more in depth, using another library, **Matplotlib**. 
-
-        **Gradient Heatmap**
-
-        Here, we'll create a colorful 2D graph of a math function using NumPy and Matplotlib!
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    import matplotlib.pyplot as plt
-    return (plt,)
-
-
-@app.cell
-def _(np):
-    x = np.linspace(-3, 3, 100)
-    y = np.linspace(-3, 3, 100)
-
-    X, Y = np.meshgrid(x, y)
-    Z = np.sin(X ** 2 + Y ** 2)
-    return X, Y, Z, x, y
-
-
-@app.cell
-def _(Z, plt):
-    plt.imshow(Z, cmap='Accent', extent=(-3, 3, -3, 3))
-    plt.title("Sinusoidal Gradient")
-    plt.colorbar()
-    plt.show()
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **What's going on here?**
-
-        Well, we used *np.linspace()*, which allowed us to create 100 values between -3 and 3. The function *np.meshgrid()* allowed us to turn x and y into 2D coordinates and plot them on a graph. Lastly, *np.sin()* applied a math function to every grid point. *Plt.imshow()*, from the Matplotlib library, allows us to visualize it. 
-
-        It's understanding if this is confusing! But this just shows us how NumPy can be used in combination with other libraries to create pretty cool visualizations.
-        """
-    )
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Simulating Human Height Data**
-
-        We can also use numpy to analyze data. For example, let's pretend we're studying a sample of 10,000 people and we want to analyze their heights.
-        """
-    )
-    return
-
-
-@app.cell
-def _(np):
-    heights = np.random.normal(loc = 170, scale = 10, size = 10000)
-    return (heights,)
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **What's happening here?**
-
-        *np.random.normal()* generates for us random values from a normal distribution. We pass in certain information, like *loc = 170* (The average height is 170 cm), *scale = 10* (The standard deviation is 10 cm) and *size = 10000* (We are simulating 10,000 individuals).
-        """
-    )
-    return
-
-
-@app.cell
-def _(heights, plt):
-    # Just like in the last example, let's visualize the data. 
-
-    plt.hist(heights, bins=50, color='skyblue', edgecolor='black')
-    plt.title("Simulated Human Heights")
-    plt.xlabel("Height (cm)")
-    plt.ylabel("Number of People")
-    plt.show()
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""A bell curve - normally distributed, and most people are near the average.""")
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Predicting Loan Payments**
-
-        Let’s say you want to model how much someone would pay per month for a small loan — similar to what a banker or budgeting app might do. This example shows us how NumPy can do financial math!
-        """
-    )
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        We'll use the basic loan formula:
-
-        $$
-        \text{Monthly Payment} = \frac{P \cdot r}{1 - (1 + r)^{-n}}
-        $$
-
-        Where P is the loan amount, r is the monthly interest rate, and n is the number of monthly payments.
-        """
-    )
-    return
-
-
-@app.cell
-def monthly_payment():
-    # First, let's create a function to define the loan formula. 
-
-    def monthly_payment(principal, annual_rate, months):
-        r = annual_rate / 12  # Convert to monthly interest rate
-        payment = (principal * r) / (1 - (1 + r) ** -months)
-        return payment
-
-    return (monthly_payment,)
-
-
-@app.cell
-def _(monthly_payment):
-    # Now we can experiment!
-
-    loan = 10000
-    rate = 0.05
-    months = 36
-
-    payment = monthly_payment(loan, rate, months)
-    print(f"Monthly payment: ${payment: .2f}")
-    return loan, months, payment, rate
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Seems pretty simple - now let's see if we can calculate payments for many loan amounts at once.""")
-    return
-
-
-@app.cell
-def _(loan, monthly_payment, np):
-    loan_amounts = np.arange(1_000, 11_000, 1_000)
-    new_rate = 0.05
-    new_months = 36
-
-    new_payments = monthly_payment(loan_amounts, new_rate, new_months)
-
-    for loan_item, pmt in zip(loan_amounts, new_payments):
-        print(f"Loan: ${loan}, Monthly Payment: ${pmt:.2f}")
-    return loan_amounts, loan_item, new_months, new_payments, new_rate, pmt
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""Because loan_ammounts is a NumPy array, the function calculates all our payments at once! Let's take a look at how to plot it.""")
-    return
-
-
-@app.cell
-def _(loan_amounts, new_payments, plt):
-    plt.plot(loan_amounts, new_payments, marker='o')
-    plt.title("Loan Amount vs. Monthly Payment")
-    plt.xlabel("Loan Amount")
-    plt.ylabel("Monthly Payment")
-    plt.grid(True)
-    plt.show()
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(r"""The graph shows us a straight line - as the loan increases, so does the payment. With NumPy, we did all the math with just one function!""")
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Bonus Challenge**
-
-        Can you calculate how much interest you would pay in total over the entire loan?
-        """
-    )
-    return
-
-
-@app.cell
-def _():
-    # Your code here!
-    # Hint: What function can you use to add everything together?
-    return
-
-
-@app.cell
-def _(mo):
-    mo.md(
-        r"""
-        **Notebook Summary**
-
-        In this notebook, we explored some of the exciting things NumPy can do — even if you're new to coding.
-        """
-    )
-    return
-
-
-if __name__ == "__main__":
-    app.run()