my-markdown-library 0.1.0

data/F24Lec_MD/lec03/3.1-Supply.md

@@ -0,0 +1,274 @@
+---
+title: "3.1-Supply"
+type: lecture-notebook
+week: 3
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec03/3.1-Supply.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, Fall 24<br>
+            Dr. Eric Van Dusen <br>
+        Shashank Dalmia <br> 
+            Ergun Acikoz <br>
+            Akhil Venkatesh 
+        </p></td></tr>
+</table>
+
+# Lecture Notebook 3.1: Supply Curves
+
+```python
+try: 
+    from csaps import csaps
+except:
+    !pip install csaps
+    from csaps import csaps
+```
+
+```python
+from datascience import *
+import matplotlib.pyplot as plt
+%matplotlib inline
+import numpy as np
+import pandas as pd
+from utils import *
+import sympy
+```
+
+```python
+from __future__ import print_function
+from ipywidgets import interact, interactive, fixed, interact_manual
+import ipywidgets as widgets
+from matplotlib import patches
+import warnings
+warnings.filterwarnings("ignore")
+```
+
+## The Supply Curve
+
+The supply of a commodity refers to the quantity for which producers or sellers are willing produce and offer for sale, at a particular price in some given period of time.
+
+To answer questions like *"at a given price, what will be the supply of a good in the market?"*, we need to know the market supply curve. A supply curve is simply a curve (or graph) which shows the quantites of a good that can be produced and the prices they will be sold at.
+
+It is good to discern between individual and market supply. **Individual supply** refers to the supply offered by a single firm or producer, while **market supply** refers to the supply offered by all the firms or producers in a market. It is the horizontal summation of the individual supply curves in the market.
+
+The following table and graph will give an example of a market with two firm: A and B.
+
+```python
+market_supply = Table().with_columns("Price", make_array(2, 3, 4),
+                                     "Quantity supplied by A", make_array(20, 30, 40),
+                                     "Quantity supplied by B", make_array(30, 40, 50),
+                                     "Market Supply", make_array(50, 70, 90))
+market_supply
+```
+
+```python
+plt.plot(market_supply.column(1), market_supply.column(0), marker='o')
+plt.plot(market_supply.column(2), market_supply.column(0), marker='o')
+plt.plot(market_supply.column(3), market_supply.column(0), marker='o')
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Market Supply')
+plt.legend(make_array("Quantity supplied by A","Quantity supplied by B","Market Supply"), bbox_to_anchor=(1.04,1), loc="center left")
+
+plt.show()
+```
+
+Market behaviour relating to supply is based on the behaviour of the individual firms that comprise it. Now, how does an individual firm make its decision about production?
+
+It does so based on the costs associated with production. If the price of a good is enough to recover the costs, the firm produces. Generally, costs increase with the quantity of production. So, to induce producers to increase the quantity supplied, the prices need to increase to compensate for the increased costs.
+
+## Costs and Firm Behavior
+
+We will split costs into two categories: **Fixed costs** and **Variable costs**.
+
+Fixed Costs are costs associated with fixed factors (or inputs) of production. For example, land for a factory, capital equipment like machinery, etc. The quantity of these inputs cannot be changed quickly in the short term. A factory owner cannot purchase land quickly enough to ramp up production in a week. A key point to note is that fixed costs are irrespective of the quantity, i.e., they do not change with the quantity produced.
+
+Variable Costs are costs associated with variable factors (or inputs) of production. For example, labor, raw materials, etc. The quantity of these inputs can be changed quickly in the short term to adjust supply. A factory owner can hire more laborers or purchase more raw material to increase output. Variable costs change as the supply changes.
+
+We will create a table with the following firm costs:
+
+* **Output:** Units produced and supplied
+* **Total Fixed Cost (TFC):** Cost incurred by firm on usage of all fixed factors.
+* **Total Variable Cost (TVC):** Cost incurred by firm on usage of all variable factors.
+* **Total Cost (TC):** Sum of the total fixed and variable costs
+* **Marginal Cost (MC):** Addition to total cost as one more unit of output is produced
+* **Average Fixed Cost (AFC):** Cost per unit of fixed factors
+* **Average Variable Cost (AVC):** Cost per unit of variable factors
+* **Average Total Cost (ATC):** Total cost per unit
+
+```python
+individual_firm_costs = Table.read_table('individual_firm_costs.csv')
+individual_firm_costs.show()
+```
+
+First, let's calculate `total_cost`, which is the sum of total fixed cost and total variable cost.
+
+```python
+total_cost = individual_firm_costs.column("Total Fixed Cost") + individual_firm_costs.column("Total Variable Cost")
+total_cost
+```
+
+We will now add the total costs array to the table.
+
+```python
+individual_firm_costs = individual_firm_costs.with_column("Total Cost", total_cost)
+individual_firm_costs
+```
+
+Average Fixed Cost can be calculated as the Total Fixed Costs divided by the output.
+
+ At zero level of output, we would by dividing by zero, which is invalid.
+ So we have to manually fix that
+
+```python
+
+average_fixed_cost = individual_firm_costs.column("Total Fixed Cost") / individual_firm_costs.column("Output")
+average_fixed_cost[0] = 0
+average_fixed_cost
+```
+
+Now we will add the AFC column back into the table.
+
+```python
+individual_firm_costs = individual_firm_costs.with_column("Average Fixed Cost", average_fixed_cost)
+individual_firm_costs
+```
+
+Similarly, Average Variable Cost can be calculated as the Total Variable Cost divided by the output.
+
+```python
+average_variable_cost = individual_firm_costs.column("Total Variable Cost")/individual_firm_costs.column("Output")
+average_variable_cost[0] = 0
+average_variable_cost
+```
+
+Now we will add the AVC column to the table.
+
+```python
+individual_firm_costs = individual_firm_costs.with_column("Average Variable Cost", average_variable_cost)
+individual_firm_costs
+```
+
+Similarly, Average Total Cost can be calculated as the Total Cost divided by the output.
+
+```python
+average_total_cost = individual_firm_costs.column("Total Cost")/individual_firm_costs.column("Output")
+average_total_cost[0] = 0
+average_total_cost
+```
+
+```python
+individual_firm_costs = individual_firm_costs.with_column("Average Total Cost", average_total_cost)
+individual_firm_costs
+```
+
+Marginal Cost can be calculated as the difference between Total Cost at the current output level and Total Cost at the previous output level (or TVC, as TFC is fixed).
+
+For this we are going to use the function `np.diff`. You can read about it on http://data8.org/fa22/reference/#array-functions-and-methods
+
+```python
+marginal_cost = np.diff(total_cost)
+marginal_cost = np.append(make_array(0), marginal_cost)
+marginal_cost
+```
+
+Once again, we add the MC column back to the table.
+
+```python
+individual_firm_costs = individual_firm_costs.with_column("Marginal Cost", marginal_cost)
+individual_firm_costs
+```
+
+Let's look at some plots!
+
+```python
+plt.plot(individual_firm_costs.column("Output"), individual_firm_costs.column("Total Fixed Cost"), marker='o')
+plt.plot(individual_firm_costs.column("Output"), individual_firm_costs.column("Total Variable Cost"), marker='o')
+plt.plot(individual_firm_costs.column("Output"), individual_firm_costs.column("Total Cost"), marker='o')
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('TFC, TVC and TC')
+plt.legend(make_array("Total Fixed Cost","Total Variable Cost","Total Cost"))
+
+plt.show()
+```
+
+What have we observed?
+
+1. TFC is flat
+2. Vertical difference between TVC and TC is TFC, which is constant
+
+```python
+plt.plot(individual_firm_costs.column("Output")[1:], individual_firm_costs.column("Average Fixed Cost")[1:], marker='o')
+plt.plot(individual_firm_costs.column("Output")[1:], individual_firm_costs.column("Average Variable Cost")[1:], marker='o')
+plt.plot(individual_firm_costs.column("Output")[1:], individual_firm_costs.column("Average Total Cost")[1:], marker='o')
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('AFC, AVC and ATC')
+plt.legend(make_array("Average Fixed Cost","Average Variable Cost","Average Total Cost"))
+
+plt.show()
+```
+
+```python
+# You do not need to understand what the code below is doing. 
+output = individual_firm_costs.column("Output")[1:]
+mc = individual_firm_costs.column("Marginal Cost")[1:]
+avc = individual_firm_costs.column("Average Variable Cost")[1:]
+atc = individual_firm_costs.column("Average Total Cost")[1:]
+
+sp_mc = csaps(output, mc, smooth=0.85)
+sp_avc = csaps(output, avc, smooth=0.85)
+sp_atc = csaps(output, atc, smooth=0.85)
+
+output_s = np.linspace(output.min(), output.max(), 150)
+mc_s = sp_mc(output_s)
+avc_s = sp_avc(output_s)
+atc_s = sp_atc(output_s)
+
+plt.plot(output, mc, marker = 'o', color = 'tab:blue')
+plt.plot(output_s, mc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:blue')
+plt.plot(output, avc, marker = 'o', color = 'tab:green')
+plt.plot(output_s, avc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:green')
+plt.plot(output, atc, marker = 'o', color = 'tab:orange')
+plt.plot(output_s, atc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:orange')
+plt.hlines(y=min(avc), xmin = 6, xmax = 8, lw=3, color='r', zorder = 10)
+plt.hlines(y=min(atc), xmin = 7.5, xmax = 9.5, lw=3, color='r', zorder = 10)
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('MC, AVC and ATC')
+plt.legend(make_array("Marginal Cost","Average Variable Cost","Average Total Cost"))
+
+plt.show()
+```
+
+Notice something important: _A company decides to produce if it the price is greater than or equal to its Average Variable Cost._
+
+There are 3 different scenarios:
+1. A firm chooses to not produce at all
+2. A firm chooses to produce at a loss (minimizing quantity)
+3. A firm chooses to produce at a profit. 
+
+Play around with the slider to see them.
+
+```python
+interact(lambda price: firm_behaviour(price, individual_firm_costs), price=widgets.IntSlider(min=20,max=60,step=1,value=25));
+```
+
+In the above example if the price is 24 for any amount of production, the firm will lose money. In this case, they shut down and the loss is limited to its fixed costs.
+
+If the price is above the minimum of the AVC (25 in the example), for some amount of production, the firm will maximise its profits (i.e. minimise its losses). Profits are Total Revenue minus Total Costs, where Total Revenue is Price times Quantity.
+
+Therefore, based on the price, each firm looks at its costs and makes a decision on whether to produce. At low prices, only the firms with the lowest production costs produce. As the price increases, firms with higher production costs find it feasible to produce and begin to supply. Thus, the market supply rises with higher prices. Firms with lower costs make extra profits.
+
+```python
+
+```
+
+```python
+
+```
+

data/F24Lec_MD/lec03/3.2-sympy.md

@@ -0,0 +1,332 @@
+---
+title: "3.2-sympy"
+type: lecture-notebook
+week: 3
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec03/3.2-sympy.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, Fall 24<br>
+            Dr. Eric Van Dusen <br>
+        <br>
+</table>
+
+# Lecture Notebook 3.2: SymPy & Market Equilibrium
+
+# SymPy - Symbolic Python
+
+```python
+from datascience import *
+import numpy as np
+from sympy import *
+from sympy import solve
+import sympy
+init_printing()
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import matplotlib.patches as patches
+%matplotlib inline
+solve = lambda x,y: sympy.solve(x-y)[0] if len(sympy.solve(x-y))==1 else "Not Single Solution"
+mpl.rcParams['figure.dpi'] = 150
+import warnings
+warnings.filterwarnings('ignore')
+```
+
+Python has many tools, such as the [SymPy library](https://docs.sympy.org/latest/tutorial/index.html) that we can use for expressing and evaluating formulas and functions in economics. 
+
+Since SymPy helps with symbolic math, we start out by create a symbol using `Symbol`, which we assign to a variable name. Then, we can use the symbols to construct symbolic expressions.
+
+```python
+x = Symbol('x');
+x
+```
+
+**Example 1**: Now let's try using SymPy to create a symbolic expression for 2 equations. Let's create the equation for the first curve. It will be called $y$ and will be in terms of `x`
+
+```python
+y = 2 * x - 3
+y
+```
+
+Similarly, we will also use `x` to express a relationship with $y_1$
+
+```python
+y_1 = 2 - x
+y_1
+```
+
+We want to see the value of `x` at which $y = y_1$. To solve this by hand, we would set up the following equation to solve for $Q$:
+
+$$
+P_D = P_S\\
+2-Q = 2Q-3
+$$
+
+Before we try solving this with SymPy, let's solve this by hand. 
+
+$$ y = y_1 $$
+$$ 2x - 3 = 2 - x $$
+$$ 3x = 5 $$
+$$ x = \frac{5}{3} $$
+
+We can confirm our `Q` value is true by plugging it back into the original equation. 
+
+$$ y = 2x - 3 $$
+$$ y = 2 \times \frac{5}{3} - 3 $$
+$$ y = \frac{1}{3} $$
+
+$$ y_1 = 2 - x $$
+$$ y_1 = 2 - (-\frac{5}{3}) $$
+$$ y_1 = \frac{1}{3} $$
+
+Using SymPy, we call `solve`, which takes in 2 arguments that represent the 2 sides of an equation and solves for the underlying variable such that the equation holds. Here, we pass in $P_D$ and $P_S$, both represented in terms of $Q$, to solve for the value of $Q$ such that $P_D=P_S$. It's good to know that `solve` is a custom function built for this class, and will be provided in the notebooks for you.
+
+```python
+x_star = solve(y, y_1)
+x_star
+```
+
+The value of $x$ that equates $y$ and $y_1$ is known as the optimal x value, and we denote it as $x^*$. Here, $x^* = \frac{5}{3}$. 
+
+With $x^*$ determined, we can substitute this value as $x$ to thus calculate $y$ or $y_1$. We substitute values using the `subs` function, which follows the syntax `expression.subs(symbol_we_want_to_substitute, value_to_substitute_with)`. This let's us see if our answer was correct.
+
+```python
+y.subs(x, x_star)
+```
+
+We can also substitute $x^*$ into $y_1$, and should get the same results.
+
+```python
+y_1.subs(x, x_star)
+```
+
+Thus, the equilibrium `x` and `y` values are $\frac{5}{3}$ and 0.33, respectively. 
+
+**Example 2** We will now put this in the context of suppply and demand. We can represent both as non-log functions. 
+
+To define an upward sloping supply curve with price expressed as a function of quantity, let's define `Q` first.
+
+```python
+Q = Symbol('Q')
+Q
+```
+
+Suppose our demand function is $\text{P}_{D}=-2 \cdot \text{Q} + 10$. $P_D$ is the price of the good purchased (how much the consumer pays). Using SymPy, this would be
+
+```python
+P_D = -2 * Q + 10
+P_D
+```
+
+The supply function is $\text{P}_{S}=3 \cdot \text{Q} + 1$. which denotes the price of the supplied good (how much the producer earns), in terms of $Q$.Using SymPy, this would be
+
+```python
+P_S = 3 * Q + 1
+P_S
+```
+
+We will now try to find the market equilibrium. The market price equilibrium $P^*$ is the price at which the quantity supplied and quantity demanded of a good or service are equal to each other. Similarly, the market quantity equilibrium $Q^*$ is the quantity at which the price paid by consumers is equal to the price received by producers. 
+
+To solve for the equilibrium given the supply and demand curve, we know that the price paid by consumers must equal to the price earned by suppliers. Thus, $P_D = P_S$, allowing us to set the two equations equal to each other and solve for the equilibrium quantity and thus equilibrium price.
+
+Combined, the price equilibrium and quantity equilibrium form a point on the graph with quantity and price as its axes, called the equilibrium point. This point is the point at which the demand and supply curves intersect.
+
+Let's take a step back and solve this by hand first.
+
+$$ P_D = P_S $$
+$$ -2Q + 10 = 3Q + 1 $$
+$$ 5Q = 9 $$
+$$ Q = \frac{9}{5} $$
+
+Now that we have our optimal Q value, let's plug it in each equation and see if our condition holds true. 
+
+$$ P_D = -2Q + 10 $$
+$$ P_D = -2 \times \frac{9}{5} + 10 $$
+$$ P_D = \frac{32}{5} = 6.4 $$
+
+$$ P_S = 3Q + 1 $$
+$$ P_S = 3 \times \frac{9}{5} + 1 $$
+$$ P_S = \frac{32}{5} = 6.4 $$
+
+Now, let's use SymPy
+
+First, we solve for the quantity equilibrium.
+
+```python
+Q_star = solve(P_D, P_S)
+Q_star
+```
+
+Next, we plug the quantity equilibrium into our demand or supply expression to get the price equilibrium
+
+```python
+P_S.subs(Q, Q_star)
+```
+
+Graphically, we can plot the supply and demand curves with quantity on the $x$ axis and price on the $y$ axis. The point at which they intersect is the equilibrium point.
+
+```python
+def plot_equation(equation, price_start, price_end, label=None):
+    plot_prices = [price_start, price_end]
+    plot_quantities = [equation.subs(list(equation.free_symbols)[0], c) for c in plot_prices]
+    plt.plot(plot_prices, plot_quantities, label=label)
+    
+def plot_intercept(eq1, eq2):
+    ex = sympy.solve(eq1-eq2)[0]
+    why = eq1.subs(list(eq1.free_symbols)[0], ex)
+    plt.scatter([ex], [why])
+    return (ex, why)
+    
+plot_equation(P_D, 0, 5)
+plot_equation(P_S, 0, 5)
+plt.ylim(0,20)
+plt.xlabel("Quantity")
+plt.ylabel("Price")
+plt.title("Supply & Demand with SymPy")
+plot_intercept(P_D, P_S);
+```
+
+# Market Equilibrium with Real Data
+
+We will now explore the relationship between price and quantity of oranges produced between 1924 and 1938. Since the [data](https://data-88e.github.io/textbook/content/references.html#demand-fruits) is from the 1920s and 1930s, it is important to remember that the prices are much lower than what they would be today because of inflation, competition, innovations, and other factors. For example, in 1924, a ton of oranges would have costed $\$6.63$; that same amount in 2019 is \$100.78, holding all factors except for inflation constant. 
+
+Remember, the **market equilibrium** is the price and quantity at which the demand and supply curves intersect. The price and resulting transaction quantity at the equilibrium is what we would predict to observe in the market. This is the point at which the demand and supply curves meet and represents the "optimal" level of production and price in that market.
+
+```python
+fruitprice = Table.read_table('fruitprice.csv')
+fruitprice
+```
+
+Let's walk through how to the market equilibrium using the market for oranges as an example.
+
+### Data Preprocessing
+
+Because we are only examining the relationship between prices and quantity for oranges, we can create a new table with the relevant columns: `Year`, `Orange Price`, and `Orange Unloads`. Here, `Orange Price` is measured in dollars, while `Orange Unloads` is measured in tons.
+
+```python
+oranges_raw = fruitprice.select("Year", "Orange Price", "Orange Unloads")
+oranges_raw
+```
+
+Next, we will rename our columns. In this case, let's rename `Orange Unloads` to `Quantity` and `Orange Price` to `Price` for brevity and understandability.
+
+```python
+oranges = oranges_raw.relabel("Orange Unloads", "Quantity").relabel("Orange Price", "Price")
+oranges
+```
+
+### Visualize the  Relationship
+
+Let's first take a look to see what the relationship between price and quantity is. We would expect to see a downward-sloping relationship between price and quantity; if a product's price increases, consumers will purchase less, and if a product's price decreases, then consumers will purchase more. 
+
+We will create a scatterplot between the points.
+
+```python
+oranges.scatter("Quantity", "Price", width=3, height=3)
+plt.title("Demand Curve for Oranges", fontsize = 16);
+```
+
+### Fit a Polynomial
+
+We will now quantify our demand curve using NumPy's [`np.polyfit` function](https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html). Recall that `np.polyfit` returns an array of size 2, where the first element is the slope and the second is the $y$-intercept.
+
+For this exercise, we will be expressing demand and supply as quantities in terms of price.
+
+```python
+orange_parameters = np.polyfit(oranges.column("Price"), oranges.column("Quantity"), 1)
+print ("The coefficient is", orange_parameters[0])
+print ("The y-intercept is", orange_parameters[1])
+```
+
+This shows that the demand curve is $D(P) = -3433 P+ 53626$. The slope is -3433 and $y$-intercept is 53626. That means that as price increases by 1 unit (in this case, \$1), quantity decreases by 3433 units (in this case, 3433 tons).
+
+### Create the Demand Curve
+
+We will now use SymPy to write out this demand curve. To do so, we start by creating a symbol `P` that we can use to create the equation.
+
+```python
+P = sympy.Symbol("P")
+demand = orange_parameters[0] * P + orange_parameters[1]
+demand
+```
+
+### Create the Supply Curve
+
+As the price of the oranges increases, the quantity of oranges that orange manufacturers are willing to supply increases. They capture the producer's side of market decisions and are upward-sloping.
+
+Let's now assume that the supply curve is given by $S(P) = 4348P$. (Note that this supply curve is not based on data.)
+
+```python
+supply_coefficient = 4348
+supply = supply_coefficient * P
+supply
+```
+
+This means that as the price of oranges increases by 1, the quantity supplied increases by 4348. At a price of 0, no oranges are supplied.
+
+### Find the Price Equilibrium
+The equilbrium consists of 2 components: the quantity equilbrium and price equilbrium. 
+The price equilibrium is the price at which the supply curve and demand curve intersect: the price of the good that consumers desire to purchase at is equivalent to the price of the good that producers want to sell at. There is no shortage of surplus of the product at this price.
+
+
+Let's find the price equilibrium. To do this, we will use the provided `solve` function. This is a custom function that leverages some SymPy magic and will be provided to you in assignments.
+
+```python
+P_star = solve(demand, supply)
+P_star
+```
+
+This means that the price of oranges that consumers want to purchase at and producers want to provide is about \$6.89.
+
+### Find the Quantity Equilibrium
+
+Similarly, the quantity equilibrium is the quantity of the good that consumers desire to purchase is equivalent to the quantity of the good that producers supply; there is no shortage or surplus of the good at this quantity.
+
+```python
+demand.subs(P, P_star)
+```
+
+```python
+supply.subs(P, P_star)
+```
+
+This means that the number of tons of oranges that consumers want to purchase and producers want to provide in this market is about 29,967 tons of oranges.
+
+### Visualize the Market Equilibrium 
+
+Now that we have our demand and supply curves and price and quantity equilibria, we can visualize them on a graph to see what they look like.
+
+```python
+def plot_equation(equation, price_start, price_end, label=None):
+    plot_prices = [price_start, price_end]
+    plot_quantities = [equation.subs(list(equation.free_symbols)[0], c) for c in plot_prices]
+    plt.plot(plot_quantities, plot_prices, label=label)
+    
+def plot_intercept(eq1, eq2):
+    ex = sympy.solve(eq1-eq2)[0]
+    why = eq1.subs(list(eq1.free_symbols)[0], ex)
+    plt.scatter([why], [ex], zorder=10, color="tab:orange")
+    return (ex, why)
+```
+
+We can leverage these functions and the equations we made earlier to create a graph that shows the market equilibrium.
+
+```python
+plot_equation(demand, 2, 12, label = "Demand")
+plot_equation(supply, 2, 12, label = "Supply")
+plt.ylim(0,13)
+plt.title("Orange Supply and Demand in 1920's and 1930's", fontsize = 15)
+plt.xlabel("Quantity (Tons)", fontsize = 14)
+plt.ylabel("Price ($)", fontsize = 14)
+plot_intercept(supply, demand)
+plt.legend(loc = "upper right", fontsize = 12)
+plt.show()
+```
+
+You can also practice on your own and download additional data sets [here](http://users.stat.ufl.edu/~winner/datasets.html), courtesy of the University of Flordia's Statistics Department.
+
+
+