my-markdown-library 0.1.0

data/F24Lec_MD/lec12/lec12-1_Interest_Payments.md

@@ -0,0 +1,267 @@
+---
+title: "lec12-1_Interest_Payments"
+type: lecture-notebook
+week: 12
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec12/lec12-1_Interest_Payments.ipynb"
+---
+
+<table style="width: 100%;">
+    <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 2024<br>
+            Dr. Eric Van Dusen <br>
+      </p></td></tr>
+</table>
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import ipywidgets as widgets
+from IPython.display import display
+import plotly.graph_objects as go
+```
+
+## Mortgage Calculator
+
+Lets build some widgets to allow you to select the 
+- Principal - amount of loan
+- Interestes Rate - annual interest rate
+- Years:  - Years of Loan term ( usually 30 or 15) 
+
+You can consult BankRate to look up resonable rates
+https://www.bankrate.com/mortgages/mortgage-rates/
+
+```python
+
+principal_widget = widgets.FloatSlider( value=200000, min=0, max=1000000, step=100, description='Principal:', readout_format='.0f', )
+annual_interest_rate_widget = widgets.FloatSlider( value=0.05, min=0, max=0.25, step=0.001, description='Interest Rate:', readout_format='.2f', )
+years_widget = widgets.IntSlider( value=30, min=1, max=50, step=1, description='Years:', readout_format='.0f', )
+
+display(principal_widget, annual_interest_rate_widget, years_widget)
+```
+
+```python
+#principal = 200000  
+#annual_interest_rate = 0.04  
+#years = 30  
+
+principal = principal_widget.value
+annual_interest_rate = annual_interest_rate_widget.value
+years = years_widget.value
+```
+
+# Formula for Mortgage Payment 
+
+$$ \text{Monthly Payment} = \frac{{\text{Principal} \cdot \left(\text{Monthly Interest Rate} \cdot \left(1 + \text{Monthly Interest Rate}\right)^{\text{Number of Payments}}\right)}}{{\left(1 + \text{Monthly Interest Rate}\right)^{\text{Number of Payments}} - 1}}
+$$
+
+## This is what we need to program into Python
+
+```python
+# Calculate monthly interest rate and number of payments
+monthly_interest_rate = annual_interest_rate / 12
+num_payments = years * 12
+
+#Calculate monthly mortgage payment
+monthly_payment = principal * (monthly_interest_rate * (1 + monthly_interest_rate)**num_payments) / ((1 + monthly_interest_rate)**num_payments - 1)
+print('Monthly payment: $%.2f' % monthly_payment)
+print('Total payment: $%.2f' % (monthly_payment * num_payments))
+print('Total interest: $%.2f' % (monthly_payment * num_payments - principal))
+print('Total Principal: $%.2f' % principal)
+print('Interest to principal ratio: %.2f' % ((monthly_payment * num_payments - principal) / principal))
+```
+
+## Lets Build a dataset of the payments over time
+- Each Monthly Payment has a share 
+- Principal paid each month
+- Interest Payement eah month
+
+### if we build this right we can graph the payments over the life of the loan
+
+```python
+payment_schedule = []
+principal_schedule = []
+interest_schedule = []
+
+
+remaining_balance = principal
+
+# This function will calculate the payments and share of interest and pricipal paid
+for month in range(1, num_payments + 1):
+    interest_payment = remaining_balance * monthly_interest_rate
+    principal_payment = monthly_payment - interest_payment
+    remaining_balance -= principal_payment
+    payment_schedule.append(monthly_payment)
+    principal_schedule.append(principal_payment)
+    interest_schedule.append(interest_payment)
+```
+
+## Let's look at the composition of the first 5 and last 5 payments
+
+```python
+print("\nPayment Schedule for the first 5 months:")
+for month in range(5):
+    print(f"Month {month + 1}: Payment ${payment_schedule[month]:.2f} (Principal ${principal_schedule[month]:.2f}, Interest ${interest_schedule[month]:.2f})")
+print("\nPayment Schedule for the last 5 months:")
+for month in range(num_payments - 5, num_payments):
+    print(f"Month {month + 1}: Payment ${payment_schedule[month]:.2f} (Principal ${principal_schedule[month]:.2f}, Interest ${interest_schedule[month]:.2f})")
+```
+
+## Now we will plot these payments over the 360 months of payback
+
+```python
+plot = go.Figure()
+plot.add_trace(go.Scatter(y=principal_schedule, name="Principal"))
+plot.add_trace(go.Scatter(y=interest_schedule, name="Interest"))
+plot.add_trace(go.Scatter(y=payment_schedule, name="Payment"))
+plot.update_layout(title="Mortgage Amortization Schedule", xaxis_title="Payment Number", yaxis_title="Payment")
+plot.show()
+```
+
+## Let's do this for an investment instead of a mortgage
+### We will calculate the future value of an investment
+### Create widgets to specify the rates
+### Slightly different than the Lab
+
+```python
+
+principal_widget = widgets.FloatSlider(value=1000, min=1, max=10000, step=1, description='Principal')
+rate_widget = widgets.FloatSlider(value=0.05, min=0.01, max=0.2, step=0.01, description='Interest Rate')
+time_widget = widgets.IntSlider(value=10, min=1, max=30, step=1, description='Time (Years)')
+n_widget = widgets.IntSlider(value=12, min=1, max=365, step=1, description='Compounding Frequency')
+display(principal_widget, rate_widget, time_widget, n_widget)
+```
+
+# Define a function to calculate future value
+
+```python
+def calculate_future_value(principal, rate, time, n):
+    years = np.arange(0, time + 1)
+    future_values = principal * (1 + rate / n) ** (n * years)
+    return years, future_values
+
+# Calculate and plot the future value of the investment
+years, future_values = calculate_future_value(principal_widget.value, rate_widget.value, time_widget.value, n_widget.value)
+
+print("At time = %d years, the future value of the investment is $%.2f" % (time_widget.value, future_values[-1]))
+```
+
+```python
+# Plot the future value of the investment over time
+
+fig = go.Figure()
+fig.add_trace(go.Scatter(x=years, y=future_values, mode='lines'))
+fig.update_layout(title="Future Value Over Time", xaxis_title="Years", yaxis_title="Future Value")
+fig.show()
+```
+
+## Here is a couple more functions to compare mortgage terms
+
+### First to compare two different interest rates
+
+You can consult BankRate to look up resonable rates
+https://www.bankrate.com/mortgages/mortgage-rates/
+
+```python
+principal_amount = 200000  # Principal amount of the loan
+loan_term_years = 30  # Loan term in years
+interest_rates_to_compare = [0.04, 0.08]  # Two different interest rates
+```
+
+```python
+def compare_interest_rates(principal, years, interest_rates):
+    results = []
+    
+    for rate in interest_rates:
+        monthly_interest_rate = rate / 12
+        num_payments = years * 12
+        monthly_payment = principal * (monthly_interest_rate * (1 + monthly_interest_rate)**num_payments) / ((1 + monthly_interest_rate)**num_payments - 1)
+        total_payment = monthly_payment * num_payments
+        total_interest_paid = total_payment - principal
+        interest_as_percent_of_payment = (total_interest_paid / total_payment) * 100
+
+        results.append({
+            "interest_rate": rate,
+            "monthly_payment": monthly_payment,
+            "total_payment": total_payment,
+            "total_interest_paid": total_interest_paid,
+            "interest_as_percent_of_payment": interest_as_percent_of_payment
+        })
+    
+    return results
+
+results = compare_interest_rates(principal_amount, loan_term_years, interest_rates_to_compare)
+
+for result in results:
+    print(f"Interest Rate: {result['interest_rate'] * 100}%")
+    print(f"Monthly Payment: ${result['monthly_payment']:.2f}")
+    print(f"Total Payment: ${result['total_payment']:.2f}")
+    print(f"Total Interest Paid: ${result['total_interest_paid']:.2f}")
+    print(f"Interest as % of Payment: {result['interest_as_percent_of_payment']:.2f}%")
+    print()
+```
+
+## Redo to can compare two different loan terms
+
+```python
+principal_amount = 200000  # Principal amount of the loan
+interest_rate = 0.05  # Annual interest rate (5%)
+loan_terms_to_compare = [15, 30] # Two most typical loan terms ( lengths)
+```
+
+```python
+def compare_loan_terms(principal, years, interest_rate):
+    results = []
+    
+    for loan_term in years:
+        # Calculate monthly interest rate and number of payments
+        monthly_interest_rate = interest_rate / 12
+        num_payments = loan_term * 12
+
+        # Calculate monthly mortgage payment
+        monthly_payment = principal * (monthly_interest_rate * (1 + monthly_interest_rate)**num_payments) / ((1 + monthly_interest_rate)**num_payments - 1)
+
+        # Calculate total payment and total interest paid
+        total_payment = monthly_payment * num_payments
+        total_interest_paid = total_payment - principal
+
+        # Calculate the total interest as a percentage of the total payment
+        interest_as_percent_of_payment = (total_interest_paid / total_payment) * 100
+
+        results.append({
+            "loan_term": loan_term,
+            "monthly_payment": monthly_payment,
+            "total_payment": total_payment,
+            "total_interest_paid": total_interest_paid,
+            "interest_as_percent_of_payment": interest_as_percent_of_payment
+        })
+    
+    return results
+
+# Example usage
+
+
+results = compare_loan_terms(principal_amount, loan_terms_to_compare, interest_rate)
+
+for result in results:
+    print(f"Loan Term: {result['loan_term']} years")
+    print(f"Monthly Payment: ${result['monthly_payment']:.2f}")
+    print(f"Total Payment: ${result['total_payment']:.2f}")
+    print(f"Total Interest Paid: ${result['total_interest_paid']:.2f}")
+    print(f"Interest as % of Payment: {result['interest_as_percent_of_payment']:.2f}%")
+    print()
+```
+
+```python
+
+```
+
+```python
+
+```
+
+```python
+
+```
+

data/F24Lec_MD/lec12/lec12-2-stocks-options.md

@@ -0,0 +1,235 @@
+---
+title: "lec12-2-stocks-options"
+type: lecture-notebook
+week: 12
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec12/lec12-2-stocks-options.ipynb"
+---
+
+<table style="width: 100%;">
+    <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 2024<br>
+            Dr. Eric Van Dusen <br>
+        Sreeja Apparaju <br>
+        Kidong Kim</p></td></tr>
+</table>
+
+# Lecture 12: Finance
+
+## This notebook takes a look at some simple tools for looking at the stock market
+ - Previously Yahooo finance had a free API for reading in historical data on stocks
+ - However the Yahoo API got discontiued
+ - An awesome quant made a python package that recreated this functionality by scraping the information
+ 
+Check out the documentation for [Yfinance package](https://pypi.org/project/yfinance/)
+
+The package - called yfinance is not on the datahub so first we need to install it
+
+```python
+try:
+    import yfinance as yf
+except:
+    !pip install yfinance
+    import yfinance as yf
+```
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib
+import matplotlib.pyplot as plt
+from datetime import timedelta, date, datetime
+from ipywidgets import interact, interactive, fixed, interact_manual
+import ipywidgets as widgets
+from IPython.display import display
+import warnings
+from datascience import *
+warnings.filterwarnings('ignore')
+%matplotlib inline
+```
+
+## S&P 500 and the Nasdaq
+
+The yfinance package allows us to download by stock ticker and make a Pandas Dataframe - here we will pull in by the market-wide tickers for the S&P 500 and the Nasdaq
+
+```python
+data_SPNQ = yf.download(("^GSPC", '^IXIC'), start="1993-01-29", end="2022-04-05")
+```
+
+The following section uses the dataframe to build out a new dataframe with returns - the amount earned each day on the previous days close
+
+```python
+data_SN = data_SPNQ.iloc[:, [2,3]]
+data_SP =data_SPNQ.iloc[:, 0]
+data_NQ = data_SPNQ.iloc[:, 1]
+dSP = np.array(len(data_SP)-1)
+for i in range(len(data_SP)-1):
+    dat = ((data_SP[i] - data_SP[i+1])/data_SP[i])*100
+    dSP = np.append(dSP,dat)
+dNQ = np.array(len(data_NQ)-1)
+for i in range(len(data_NQ)-1):
+    dat = ((data_NQ[i] - data_NQ[i+1])/data_NQ[i])*100
+    dNQ = np.append(dNQ,dat)
+data_SN['SP Returns'] = dSP
+data_SN['NQ Returns'] = dNQ
+```
+
+```python
+data_SN.iloc[:,[0,1]].plot(color = ('blue', 'red'), figsize=(10,8), alpha =0.3);
+```
+
+```python
+data_SN[['SP Returns', 'NQ Returns']].iloc[1:].plot(color = ('blue', 'red'), figsize=(10,8), alpha = 0.3);
+```
+
+```python
+data_SN.iloc[:,[0,1]].plot(color = ('blue', 'red'), figsize=(10,8), alpha =0.3);
+```
+
+```python
+data_SN[['SP Returns', 'NQ Returns']].iloc[1:].plot(color = ('blue', 'red'), figsize=(10,8), alpha = 0.3);
+```
+
+## Let's dive deeper into the Yfinance API and and work with the data
+
+First we will define three stocks that we want to look at more closely, and examine what sort of information we can get for each stock.  
+
+Lets look at 
+ - Twitter
+ - Tesla
+ - USO - an ETF (exchange traded fund) that tracks the price of oil
+
+```python
+twitter_ticker = yf.Ticker("twtr")
+tesla_ticker = yf.Ticker("tsla")
+uso_ticker = yf.Ticker("uso")
+```
+
+There is actually a lot of information that yfinance API can provide for any equity.  In the example above we only downloaded the closing price for each of the indexes.
+
+```python
+#tesla_ticker.info
+```
+
+## Out of all this info - let's extract the stock prices
+
+This will put the dates, prices, and volumes into a *Pandas* dataframe with the name of the stock
+
+```python
+#twitter = twitter_ticker.history(period="max")
+tesla = tesla_ticker.history(period="max")
+uso = uso_ticker.history(period="max")
+```
+
+```python
+tesla
+```
+
+## Lets look at the market for Options for Twitter 
+ - This will show us the possible strike dates for different options
+ - From short term - this week - to long term - in two years
+
+```python
+tesla_ticker.options
+```
+
+## Downloading Calls and Puts 
+Let's download all of the Calls and Puts for Tesla  into two tables
+
+```python
+tesla_options = tesla_ticker.option_chain(tesla_ticker.options[0])
+```
+
+```python
+tesla_options.calls
+```
+
+```python
+# Returns two table 0 : calls, 1 : puts
+tesla_options = tesla_ticker.option_chain(tesla_ticker.options[0])
+tesla_put , tesla_call = tesla_options.puts, tesla_options.calls
+relevant_columns = ['lastPrice', 'change', 'percentChange', 'volume', 'strike']
+tesla_put, tesla_call = tesla_put[relevant_columns], tesla_call[relevant_columns]
+tesla_put.describe(), tesla_call.describe()
+```
+
+## Let's put these together into a joint table that are joined by the strike price
+
+```python
+tesla_option = pd.merge(tesla_put, tesla_call, how='inner', on = "strike")
+#tesla_option = pd.merge(tesla_put, tesla_call, how='outer', on = "strike")
+tesla_option[12:32]
+```
+
+## Now lets code up a graph of the puts and calls for Tesla
+
+```python
+current_tesla_p = tesla.iloc[-1]['Close']
+current_tesla_p
+
+plt.figure().set_size_inches(15, 5)
+
+plt.title("Tesla calls vs puts",  fontsize=15)
+
+plt.plot(tesla_option['strike'], tesla_option['lastPrice_x'], color='r', label='call', linewidth=3)
+plt.plot(tesla_option['strike'], tesla_option['lastPrice_y'], color='b', label='put', linewidth=3)
+plt.axvline(x = current_tesla_p, color = 'g', label = 'Current Price', linewidth=4) #Current Price
+
+plt.axis([tesla_option['strike'].iloc[0], tesla_option['strike'].iloc[-1], 0, max(max(tesla_option['lastPrice_x']), max(tesla_option['lastPrice_y']))])
+plt.legend()
+```
+
+```python
+def option(ticker):
+  options_obj = ticker.option_chain(ticker.options[0])
+  put, call = options_obj.puts, options_obj.calls
+  relevant_columns = ['lastPrice', 'change', 'percentChange', 'volume', 'strike']
+  put, call = put[relevant_columns], call[relevant_columns]
+  option_sheet = pd.merge(put, call, how='inner', on = "strike")
+  return option_sheet
+
+option(uso_ticker)
+```
+
+## QuantStats Package
+The same developer made a more recent package that draws on Yfinance but makes a whole set of summary tables 
+
+Check out the documentation for the [QuantStats Package](https://pypi.org/project/QuantStats/)
+
+```python
+try:
+    import quantstats as qs
+except:
+    !pip install quantstats
+    import quantstats as qs
+```
+
+```python
+import quantstats as qs
+
+# extend pandas functionality with metrics, etc.
+qs.extend_pandas()
+
+# fetch the daily returns for a stock
+stock = qs.utils.download_returns('TSLA')
+
+# show sharpe ratio
+qs.stats.sharpe(stock)
+
+# or using extend_pandas() :)
+stock.sharpe()
+```
+
+### QuantStats can make a "Snapshot" of stock performance
+
+```python
+qs.plots.snapshot(stock, title='Tesla Performance')
+```
+
+## Relevant materials and sources
+
+https://algotrading101.com/learn/yfinance-guide/ <br>
+https://pypi.org/ <br>
+https://pypi.org/project/QuantStats/
+

data/F24Lec_MD/lec13/Co2_ClimateChange.md

@@ -0,0 +1,139 @@
+---
+title: "Co2_ClimateChange"
+type: lecture-notebook
+week: 13
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec13/Co2_ClimateChange.ipynb"
+---
+
+## Carbon Dioxide Emissions and Global Climate Change
+
+This notebook is a very simple analysis of global carbon emissons and global temperature change.
+
+- The first point is to load the data directly from the government agencies that manage it.   
+- The second is to plot the data and see that we are at the hightest levels of carbon emissions in history.  
+- The third is to plot the data and see that we are at the highest levels of global temperature in history.  
+- The fourth is to plot the two data series and see that there is a correlation between the two.
+
+```python
+import pandas as pd
+import plotly.express as px
+```
+
+## Global Atmospheric Carbon Levels
+
+The CO2 data is from the Global Monitoring Laboratory of the National Oceanic and Atmospheric Administration (NOAA).  The most frequently cited data is the Mauna Loa Observatory in Hawaii.  
+
+![NOAA](https://upload.wikimedia.org/wikipedia/commons/1/11/NOAA_logo_mobile.svg)
+
+The data is available at https://www.esrl.noaa.gov/gmd/ccgg/trends/data.html.
+
+There are many data series, but we have selected monthly mean data, which are available as a csv.  
+
+Mauna Loa Obervatory is at the top of a volcano in the middle of the Pacific Ocean.  It is a good place to measure CO2 because it is far from any major sources of CO2.  The data is available from 1958 to the present.  The data is in parts per million (ppm) of CO2 in the atmosphere.
+
+```python
+url_mlo_co2="https://gml.noaa.gov/webdata/ccgg/trends/co2/co2_mm_mlo.csv"
+
+df_mlo_co2 = pd.read_csv(url_mlo_co2, comment='#')
+
+df_mlo_co2
+```
+
+### Let's graph the monthly level of Co2 over time to see the trend.
+
+This is potentially one of the most famous graphs in the world.  It is called the Keeling Curve, after Charles David Keeling, who started the measurements in 1958.  The graph shows the monthly mean level of CO2 in the atmosphere.
+
+```python
+
+
+fig = px.line(df_mlo_co2, x='decimal date', y='average', title='Mauna Loa CO₂ daily means')
+fig.show()
+```
+
+## GISS Surface Temperature Analysis (GISTEMP v4) ##
+
+This dataset is the GISS Surface Temperature Analysis (GISTEMP v4) provided by NASA's Goddard Institute for Space Studies. The dataset is updated on a monthly basis and is available from 1880 to the present. The dataset is a combination of land-surface air temperatures and sea-surface water temperatures. The data is provided in tabular format and is available for global, hemispheric, and zonal means. The data is provided as temperature anomalies, which are deviations from the 1951-1980 means. The data is available in csv files and is updated through the most recent month.
+
+![NASA](https://www.giss.nasa.gov/gfx/2013/nasa_x2.png)
+
+The data is available from the following URL:
+https://data.giss.nasa.gov/gistemp/
+
+We have chosen the following datasets for this analysis:
+
+**Global-mean monthly, seasonal, and annual means, 1880-present, updated through most recent month**
+
+```python
+url_giss_temp = 'https://data.giss.nasa.gov/gistemp/tabledata_v4/GLB.Ts+dSST.csv'
+
+giss_temp = pd.read_csv(url_giss_temp, skiprows=1)
+
+giss_temp
+```
+
+Lets plot the data to see the trend in global temperature over time.
+
+MAM is the variable name for Monthly Anomaly Means.  The data is in degrees Celsius.
+
+```python
+fig = px.line(giss_temp, x='Year', y='MAM', title='Global temperature anomaly')
+fig.show()
+```
+
+## Correlation between CO2 and Global Temperature ##
+
+Let's check the correlation between the two datasets.  
+
+First we need to cut the temperatture anomoly data to match the CO2 data.  The CO2 data is from 1958 to the present.  The temperature data is from 1880 to the present.  We will cut the temperature data to match the CO2 data.  
+
+Then we will make an annual CO2 dataset by taking the average of the monthly data.
+
+Finally we will merge the two datasets on the year.
+
+```python
+# cut temp  data to 1958 
+giss_temp = giss_temp[giss_temp['Year'] >= 1958]
+```
+
+```python
+# make an annual graph for the Co2 data
+#df_mlo_co2['year'] = df_mlo_co2['decimal date'].apply(lambda x: int(x))
+annual_co2 = df_mlo_co2.groupby('year').mean().reset_index()
+annual_co2
+```
+
+```python
+#merge with co2 data
+merged_co2_temp = pd.merge(annual_co2, giss_temp, left_on='year', right_on='Year')
+```
+
+```python
+merged_co2_temp
+```
+
+```python
+#graph over time using plotly for the merged data
+fig = px.scatter(merged_co2_temp, x='average', y='MAM', 
+    title='CO₂ vs global temperature anomaly',
+    labels={'average':'CO₂ (ppm)', 'MAM':'Temperature anomaly (°C)'},
+    trendline='ols')
+# add a trendline
+
+
+fig.show()
+```
+
+```python
+#calculate the correlation
+correlation = merged_co2_temp['average'].corr(merged_co2_temp['MAM'])
+print(correlation)
+```
+
+
+
+
+
+```python
+
+```
+