init

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[theme]
+base="light"

README.md

@@ -1,13 +1,8 @@
----
-title: Buy Or Rent
-emoji: 📚
-colorFrom: yellow
-colorTo: red
-sdk: streamlit
-sdk_version: 1.26.0
-app_file: app.py
-pinned: false
-license: mit
----
+# Opensource Buy or Rent Calculator
+https://buy-or-rent.streamlit.app/
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+tl;dr: I was frustrated by online buy vs rent calculators because they 1. tend to ignore the time value of money, and 2. Don't reflect risk and uncertainty. So I made my own open-source calculator.
+
+To give an example, this calculator (https://smartmoneytools.co.uk/tools/rent-vs-buy/) simply adds up all the costs and returns regardless of time. This means that £100 today is treated the same as £100 in 10 years. This is highly inaccurate because it fails to take into account the time value of money. This way of calculating the result underestimates the impact of periodic payments like rent and mortgage as well as initial payments like stamp duty, compared to the future property value.
+
+Moreover, the uncertainty involved in comparing buying vs renting is really why I wanted to make this. Online calculators allow you to set a single number for parameters like the mortgage rate, but no one can really be certain what these numbers will be. Whether you choose 2% or 3% is mostly arbitrary, so I wanted to see what happens if you allow the input to be a probability density function.

requirements.txt

@@ -0,0 +1,7 @@
+streamlit==1.26.0
+pandas
+numpy
+numpy_financial
+scipy
+seaborn
+matplotlib

src/app.py

@@ -0,0 +1,138 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from main import Buy_or_Rent_Model, generate_combinations_and_calculate_npv, graph_kde_plots
+from utils.general import get_param_distribution
+
+
+# Streamlit app title
+st.title('Open Source UK Buy or Rent Simulation Model')
+st.write("---")
+st.write("Not sure whether it is financially better to buy a property or rent and invest? We use simulations to show possible returns for buying a property or renting given your assumptions. All parameters are assumed to be uncorrelated.")
+
+st.markdown("***This app is currently in Beta. It assumes that you are in England, UK. Different countries may have different tax rules. No data is collected by this app. The source code can be found at: https://github.com/edisonymy/buy_or_rent***")
+st.write("---")
+
+n_samples = 500
+n_bins = 30
+
+np.random.seed(123)
+
+# User-enterable parameters for data generation
+st.subheader('Your Assumptions')
+with st.expander("Expand", expanded=True):
+    # st.sidebar.subheader('Fixed Model Parameters:')
+    house_price = st.number_input("Property Price", value=300000, step = 5000)
+    # rental_yield = st.sidebar.number_input("Rental Yield (used to calculate monthly rent for equivalent property):", value=0.043, step = 0.001, format="%.3f") #st.sidebar.slider('Rental Yield (used to calculate monthly rent for equivalent property):', min_value=0.01, max_value=1.0, value=0.044, format="%.3f")
+    # implied_monthly_rent = house_price * rental_yield / 12
+    # st.sidebar.write(f"Monthly Rent: {implied_monthly_rent:.0f}")
+    monthly_rent = st.number_input("Monthly Rent:", value=int(house_price*0.043/12), step = 100)
+    rental_yield = (12 * monthly_rent)/ house_price
+    st.markdown(f"<span style='font-size: 12px;'>Implied Rental Yield: {rental_yield:.3f}</span>", unsafe_allow_html=True)
+    text = 'Checkout a rental yield map here: https://www.home.co.uk/company/press/rental_yield_heat_map_london_postcodes.pdf'
+    st.markdown(f"<span style='font-size: 11px;'>{text}</span>", unsafe_allow_html=True)
+
+    deposit = st.slider('Deposit:', min_value=0, max_value=house_price, value=int(0.4*house_price), step = 1000)
+    deposit_mult = deposit/house_price
+    # deposit_mult = st.sidebar.slider('Deposit percentage:', min_value=0.01, max_value=1.0, value=0.4)
+    # st.sidebar.markdown(f"<span style='font-size: 12px;'>Deposit Amount: {deposit:,.0f}</span>", unsafe_allow_html=True)
+    mortgage_length = st.slider('Mortgage Length:', min_value=15, max_value=35, value=30, step = 1)
+    
+    st.markdown("***For advanced options, please use the left sidebar (mobile users please press the top left button).***")
+
+# sidebar 
+st.write("---")
+st.sidebar.subheader('Additional Parameters:')
+stamp_duty_bol = st.sidebar.checkbox('I pay Stamp Duty.', value = False, help="Stamp Duty (UK): A tax paid by the buyer when purchasing property in the United Kingdom. The amount of Stamp Duty depends on the property's purchase price and may include additional rates for second homes and buy-to-let properties.") 
+cgt_bol = st.sidebar.checkbox('I pay capital gains tax on the property.', value = False, help = "Capital Gains Tax (CGT): A tax levied on the profit (capital gain) made from the sale or disposal of assets such as property, investments, or valuable possessions. The amount of CGT owed is typically calculated based on the difference between the purchase price and the selling price of the asset. Different rates may apply to individuals and businesses, and there are often exemptions and allowances that can reduce the taxable amount.")
+cgt_investment_bol = st.sidebar.checkbox('I pay capital gains tax on the investment.', value = False, help = "Capital Gains Tax (CGT): A tax levied on the profit (capital gain) made from the sale or disposal of assets such as property, investments, or valuable possessions. The amount of CGT owed is typically calculated based on the difference between the purchase price and the selling price of the asset. Different rates may apply to individuals and businesses, and there are often exemptions and allowances that can reduce the taxable amount.")
+ongoing_cost = st.sidebar.number_input("Annual combined maintenance and service charge:", value=int(house_price*0.006), step = 100, help="The total annual cost associated with maintaining and servicing a property, including expenses such as property management fees, maintenance fees, and other related charges.")
+buying_cost = st.sidebar.number_input("Buying cost (excluding stamp duty):", value=3000, step = 100, help="This includes laywer's fee, mortgage lender fees, surveyor's fee, valuation fees and other fees you expect to pay at the time of purchase.")
+annual_income = st.sidebar.number_input("Annual Salary", value=20000, step = 100, help="This should be set to the expected salary at time of sale, required to calculate capital gains tax.")
+selling_cost_no_cgt = st.sidebar.number_input("Selling cost (excluding Capital Gains Tax):", value=int(house_price*0.02), step = 100, help= "Total expense incurred when selling a property. This typically include real estate agent commissions, legal fees, advertising expenses, and any necessary repairs or renovations to prepare the property for sale.")
+inflation = st.sidebar.number_input('Inflation:', min_value=0.0, max_value=1.0, value=0.02, step = 0.001, format="%.3f", help="Used for inflation adjustment only. It does not affect the model.")
+# uncertain parameters
+st.sidebar.subheader('Advanced Model Parameters:')
+st.sidebar.write("It's hard to predict the future, so this section allows the simulations to reflect your uncertainty. The more uncertain you are about a paramter, the higher the standard deviation (sd) you should assume.")
+mortgage_interest_annual_mean = st.sidebar.slider('Mortgage Interest Rate Mean:', min_value=0.01, max_value=0.1, value=0.055, step = 0.001, format="%.3f")
+mortgage_interest_annual_std = st.sidebar.slider('Mortgage Interest Rate sd:', min_value=0.0, max_value=0.1, value=0.012, step = 0.001, format="%.3f")
+text = 'Check out historical mortgage rates here: https://tradingeconomics.com/united-kingdom/mortgage-rate'
+st.sidebar.markdown(f"<span style='font-size: 11px;'>{text}</span>", unsafe_allow_html=True)
+mortgage_interest_annual_list = get_param_distribution(mortgage_interest_annual_mean, mortgage_interest_annual_std, n_samples, n_bins, title ='Assumed Distribution for Average Mortgage Interest Rate')
+st.sidebar.write("---")
+property_price_growth_annual_mean = st.sidebar.slider('Property Price Growth Mean:', min_value=0.01, max_value=0.1, value=0.03, step = 0.001, format="%.3f")
+property_price_growth_annual_std = st.sidebar.slider('Property Price Growth sd:', min_value=0.0, max_value=0.05, value=0.01, step = 0.001, format="%.3f")
+text = 'Check out historical property price growth here: https://www.ons.gov.uk/economy/inflationandpriceindices/bulletins/housepriceindex/june2023'
+st.sidebar.markdown(f"<span style='font-size: 11px;'>{text}</span>", unsafe_allow_html=True)
+property_price_growth_annual_list = get_param_distribution(property_price_growth_annual_mean, property_price_growth_annual_std, n_samples, n_bins, title ='Assumed Distribution for Annual Property Value Growth')
+st.sidebar.write("---")
+rent_increase_mean = st.sidebar.slider('Rent Increase Mean:', min_value=0.01, max_value=0.1, value=0.02, step = 0.001, format="%.3f")
+rent_increase_std = st.sidebar.slider('Rent Increase sd:', min_value=0.0, max_value=0.05, value=0.01, step = 0.001, format="%.3f")
+text = 'Checkout historical rent increases here: https://www.ons.gov.uk/economy/inflationandpriceindices/bulletins/indexofprivatehousingrentalprices/july2023'
+st.sidebar.markdown(f"<span style='font-size: 11px;'>{text}</span>", unsafe_allow_html=True)
+rent_increase_list = get_param_distribution(rent_increase_mean, rent_increase_std, n_samples, n_bins, title ='Assumed Distribution for Average Annual Rent Increase')
+st.sidebar.write("---")
+investment_return_annual_mean = st.sidebar.slider('Investment Return Mean:', min_value=0.01, max_value=0.2, value=0.06, step = 0.001, format="%.3f")
+investment_return_annual_std = st.sidebar.slider('Investment Return sd:', min_value=0.0, max_value=0.05, value=0.02, step = 0.001, format="%.3f")
+text = 'Check out historical stock market returns here: https://www.investopedia.com/ask/answers/042415/what-average-annual-return-sp-500.asp'
+st.sidebar.markdown(f"<span style='font-size: 11px;'>{text}</span>", unsafe_allow_html=True)
+investment_return_annual_list = get_param_distribution(investment_return_annual_mean, investment_return_annual_std, n_samples, n_bins, title ='Assumed Distribution for Average Investment Rate of Return')
+st.sidebar.write("---")
+years_until_sell_mean = st.sidebar.slider('Years Until Sell Mean:', min_value=0, max_value=100, value=15)
+years_until_sell_std = st.sidebar.slider('Years Until Sell sd:', min_value=0, max_value=10, value=5)
+years_until_sell_list = get_param_distribution(years_until_sell_mean, years_until_sell_std, n_samples, n_bins, as_int=True, title ='Assumed Distribution for Years Until Property Is Sold')
+st.sidebar.write("---")
+# n_samples = st.sidebar.slider('Number of Samples:', min_value=100, max_value=50000, value=10000)
+# n_bins = st.sidebar.slider('Number of Bins:', min_value=10, max_value=100, value=30)
+st.sidebar.subheader('Simulation Settings:')
+n_samples_simulation = st.sidebar.slider('Number of Simulation Samples:', min_value=100, max_value=10000, value=500)
+
+# Initialize the model
+model = Buy_or_Rent_Model()
+model.HOUSE_PRICE = house_price
+model.DEPOSIT_MULT = deposit_mult
+model.RENTAL_YIELD = rental_yield
+model.MORTGAGE_LENGTH = mortgage_length
+model.ANNUAL_SALARY = annual_income
+model.ONGOING_COST_MULT = ongoing_cost/house_price
+model.BUYING_COST_FLAT = buying_cost
+model.STAMP_DUTY_BOL = stamp_duty_bol
+model.CGT_BOL = cgt_bol
+model.CGT_INVESTMENT_BOL = cgt_investment_bol
+model.inflation = inflation
+
+# Generate combinations and calculate NPV
+percentiles_df, results_df = generate_combinations_and_calculate_npv(
+    n_samples_simulation,
+    model,
+    mortgage_interest_annual_list=mortgage_interest_annual_list,
+    property_price_growth_annual_list=property_price_growth_annual_list,
+    rent_increase_list=rent_increase_list,
+    investment_return_annual_list=investment_return_annual_list,
+    years_until_sell_list=years_until_sell_list
+)
+
+# Display the results DataFrame
+# st.subheader('Correlations Between Parameters and Buying NPV')
+with st.expander('Correlations Between Parameters and Buying NPV', expanded=False):
+    st.write(results_df.corr().iloc[0,1:])
+
+st.write('---')
+st.write("If you found this useful and want to support me, consider buying me a coffee here:")
+# Embed the "Buy Me a Coffee" button script with custom CSS
+buy_me_a_coffee_html = """
+<script type="text/javascript" src="https://cdnjs.buymeacoffee.com/1.0.0/button.prod.min.js"
+    data-name="bmc-button" data-slug="edisonymyt" data-color="#FFDD00" data-emoji="☕" data-font="Cookie"
+    data-text="Buy me a coffee" data-outline-color="#000000" data-font-color="#000000"
+    data-coffee-color="#ffffff" ></script>
+"""
+
+# Display the custom CSS and the button in the Streamlit app
+st.components.v1.html(buy_me_a_coffee_html)
+# plot_button = st.button("Plot Additional Graphs")
+
+# Check if the button is clicked
+# if plot_button:
+#     FEATURES = ['mortgage_interest_annual', 'property_price_growth_annual', 'rent_increase', 'investment_return_annual', 'years_until_sell']
+#     graph_kde_plots(results_df,FEATURES)

src/main.py

@@ -0,0 +1,312 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import numpy_financial as npf
+from scipy.stats import norm, skew
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+import seaborn as sns
+from utils.general import calculate_percentiles, bin_continuous_features, get_param_distribution
+from utils.finance import get_stamp_duty_next_home, annuity_pv, annuity_fv, annuity_payment, pv_future_payment, fv_present_payment
+
+import warnings
+warnings.simplefilter(action='ignore', category=FutureWarning)
+matplotlib.rcParams["axes.formatter.limits"] = (-99, 99)
+
+def format_with_commas(x, pos):
+    return '{:,.0f}'.format(x)
+
+class Buy_or_Rent_Model():
+    def __init__(self) -> None:
+        # PARAMS
+        # Fixed (in expectation)
+        self.HOUSE_PRICE = 800000 #including upfront repairs and renovations 
+        self.RENTAL_YIELD = 0.043 # assumed rent as a proportion of house price https://www.home.co.uk/company/press/rental_yield_heat_map_london_postcodes.pdf
+        self.DEPOSIT_MULT = 0.5
+        self.MORTGAGE_LENGTH = 30
+        self.BUYING_COST_FLAT = 3000 #https://www.movingcostscalculator.co.uk/calculator/
+        self.SELLING_COST_MULT = 0.02 #https://www.movingcostscalculator.co.uk/calculator/
+        self.ONGOING_COST_MULT = 0.006 # service charge + repairs, council tax and bills are omitted since they are the same whether buying or renting
+        self.ANNUAL_SALARY = 55000
+        self.CGT_ALLOWANCE = 6000
+        self.PERSONAL_ALLOWANCE = 12570
+        self.CGT_BOL = True
+        self.CGT_INVESTMENT_BOL = False
+        self.STAMP_DUTY_BOL = True
+        # Probability distribution
+        self.rent_increase = 0.01325 # historical: https://www.ons.gov.uk/economy/inflationandpriceindices/bulletins/indexofprivatehousingrentalprices/april2023
+        self.property_price_growth_annual = 0.025 # historical average = 0.034 over the last 8 year, adjusted down due to end to abnormally low interest rates; source for historical data: https://www.statista.com/statistics/620414/monthly-house-price-index-in-london-england-uk/
+        self.mortgage_interest_annual = 0.05
+        self.investment_return_annual = 0.06
+        self.years_until_sell = 20
+        # financial modelling params
+        self.inflation = 0.02 #on ongoing costs, also for converting fv
+        self.adjust_for_inflation = 0
+
+    def get_capital_gains_tax_property(self):
+        cgt = 0
+        if self.CGT_BOL:
+            taxable_gains = self.future_house_price - self.HOUSE_PRICE
+            if self.ANNUAL_SALARY > 50271:
+                cgt = taxable_gains * 0.28
+            else:
+                taxable_income = self.ANNUAL_SALARY - self.PERSONAL_ALLOWANCE
+                if taxable_gains - self.CGT_ALLOWANCE + taxable_income <= 50270:
+                    cgt = (taxable_gains - self.CGT_ALLOWANCE) * 0.18
+                else:
+                    cgt += (50271 - taxable_income) * 0.18
+                    cgt += (taxable_gains - self.CGT_ALLOWANCE - 50271) * 0.28
+        return cgt
+    
+    def get_capital_gains_tax_investment(self):
+        cgt = 0
+        if self.CGT_INVESTMENT_BOL:
+            taxable_gains = self.total_investment_fv - self.total_investment
+            if self.ANNUAL_SALARY > 50271:
+                cgt = taxable_gains * 0.2
+            else:
+                taxable_income = self.ANNUAL_SALARY - self.PERSONAL_ALLOWANCE
+                if taxable_gains - self.CGT_ALLOWANCE + taxable_income <= 50270:
+                    cgt = (taxable_gains - self.CGT_ALLOWANCE) * 0.1
+                else:
+                    cgt += (50271 - taxable_income) * 0.1
+                    cgt += (taxable_gains - self.CGT_ALLOWANCE - 50271) * 0.2
+        return cgt
+
+    def run_calculations(self, adjust_for_inflation_bool = False):
+        self.future_house_price = self.HOUSE_PRICE * (1+self.property_price_growth_annual)**self.years_until_sell
+        self.CGT = self.get_capital_gains_tax_property()
+        self.SELLING_COST = self.future_house_price * self.SELLING_COST_MULT + self.CGT
+        if adjust_for_inflation_bool:
+            self.adjust_for_inflation = self.inflation
+            # self.SELLING_COST = self.SELLING_COST / float(1+self.adjust_for_inflation)**(self.years_until_sell)
+            # self.future_house_price = self.future_house_price / float(1+self.adjust_for_inflation)**(self.years_until_sell)
+        self.monthly_rent = self.HOUSE_PRICE * self.RENTAL_YIELD /12
+        if self.STAMP_DUTY_BOL:
+            self.STAMP_DUTY = get_stamp_duty_next_home(self.HOUSE_PRICE)
+        else:
+            self.STAMP_DUTY = 0
+        self.discount_rate = self.investment_return_annual
+        self.DEPOSIT = self.HOUSE_PRICE * self.DEPOSIT_MULT
+        self.mortgage_calculations()
+        self.get_house_buying_npv()
+        self.get_house_buying_fv()
+        self.get_renting_fv()
+
+    def mortgage_calculations(self):
+        self.mortgage_amount = self.HOUSE_PRICE * (1 - self.DEPOSIT_MULT)
+        self.annual_mortgage_payment = annuity_payment(self.mortgage_amount, self.mortgage_interest_annual,self.MORTGAGE_LENGTH,0)
+        self.pv_mortage_payments = annuity_pv(self.annual_mortgage_payment, self.discount_rate, self.MORTGAGE_LENGTH, 0)
+        self.fv_mortgage_payments = pv_future_payment(annuity_fv(self.annual_mortgage_payment, self.discount_rate, self.MORTGAGE_LENGTH, 0), self.discount_rate, self.MORTGAGE_LENGTH - self.years_until_sell)/ float(1+self.adjust_for_inflation)**(self.years_until_sell)#annuity_fv(self.annual_mortgage_payment, self.discount_rate, self.MORTGAGE_LENGTH, 0)
+
+    def get_house_buying_npv(self):
+        self.pv_of_future_house_price = pv_future_payment(self.future_house_price, self.discount_rate, self.years_until_sell)
+        self.pv_of_selling_cost = pv_future_payment(self.SELLING_COST, self.discount_rate, self.years_until_sell)
+        self.pv_ongoing_cost = annuity_pv(self.HOUSE_PRICE * self.ONGOING_COST_MULT,self.discount_rate, self.years_until_sell, self.inflation)
+        # rent saved
+        self.pv_rent_saved = annuity_pv(self.HOUSE_PRICE*self.RENTAL_YIELD, self.discount_rate, self.years_until_sell, self.rent_increase)
+        # sum it up
+        self.buying_npv = self.pv_of_future_house_price + self.pv_rent_saved - self.pv_mortage_payments- self.pv_ongoing_cost - self.DEPOSIT  - self.BUYING_COST_FLAT - self.STAMP_DUTY - self.pv_of_selling_cost
+
+    def get_house_buying_fv(self): # not accounting for deposit,  immediate costs, and rent saved. ongoing costs and mortgage are rolled up and deducted from fv
+        if self.adjust_for_inflation > 0:
+            self.SELLING_COST = self.SELLING_COST / float(1+self.adjust_for_inflation)**(self.years_until_sell)
+            self.future_house_price = self.future_house_price / float(1+self.adjust_for_inflation)**(self.years_until_sell)
+        self.fv_ongoing_cost = annuity_fv(self.HOUSE_PRICE * self.ONGOING_COST_MULT,self.discount_rate, self.years_until_sell, self.inflation, adjust_for_inflation = self.adjust_for_inflation)
+        self.rent_fv = annuity_fv(self.HOUSE_PRICE*self.RENTAL_YIELD, self.discount_rate, self.years_until_sell, self.rent_increase, adjust_for_inflation = self.adjust_for_inflation)
+        self.buying_fv = self.future_house_price + self.rent_fv - self.SELLING_COST - self.fv_ongoing_cost -  self.fv_mortgage_payments
+        # self.buying_pv = self.pv_of_future_house_price + self.pv_rent_saved - self.pv_of_selling_cost - self.pv_ongoing_cost -  self.pv_mortage_payments
+        # self.buying_fv_inflation_adjusted = pv_future_payment(self.buying_fv, self.inflation, self.years_until_sell)
+
+    def get_renting_fv(self): # assumes that buying costs and stamp duty are invested, rent is rolled up and deducted
+        self.total_investment = self.BUYING_COST_FLAT + self.STAMP_DUTY + self.DEPOSIT
+        self.total_investment_fv = fv_present_payment(self.total_investment, self.discount_rate, self.years_until_sell, adjust_for_inflation = self.adjust_for_inflation)
+        # fv_buying_cost = fv_present_payment(self.BUYING_COST_FLAT, self.discount_rate, self.years_until_sell, adjust_for_inflation = self.adjust_for_inflation)
+        # fv_STAMP_DUTY = fv_present_payment(self.STAMP_DUTY, self.discount_rate, self.years_until_sell, adjust_for_inflation = self.adjust_for_inflation)
+        # deposit_fv = fv_present_payment(self.DEPOSIT, self.discount_rate, self.years_until_sell, adjust_for_inflation = self.adjust_for_inflation)
+        self.cgt_investment = self.get_capital_gains_tax_investment()
+        self.renting_fv = self.total_investment_fv - self.cgt_investment
+        # self.renting_pv = self.total_investment
+        # self.renting_fv_inflation_adjusted = pv_future_payment(self.renting_fv, self.inflation, self.years_until_sell)
+
+def plot_kde_from_list(arrays, st, figsize=(7, 2), main_colors = ['green'], secondary_color = 'red', legends = None, title = 'Net Present Value Probability Distribution', xlabel = 'Net Present Value For Property Purchase'):
+    fig, ax = plt.subplots(figsize=figsize)
+    x_lower = []
+    x_higher = []
+    for num, array in enumerate(arrays):
+        # Plot the entire KDE plot in one color
+        sns.kdeplot(data=array, ax=ax, color=main_colors[num-1], fill=True, bw_adjust = 2, label='Entire KDE', clip=(0, None))
+
+        # Plot the shaded area to the left of 0 in a different color
+        sns.kdeplot(data=array, ax=ax, color=secondary_color, fill=True, bw_adjust = 2, label='Shaded Area', clip=(None, 0))
+        # x_low_percentile = np.percentile(array, 0.001)
+        # x_high_percentile = np.percentile(array, 99)
+        x_mean = np.mean(array)
+        x_std = np.std(array)
+        x_lower.append(x_mean-3*x_std)
+        x_higher.append(x_mean+3*x_std)
+    
+    # Set the axis limits based on the 95th percentile
+    ax.xaxis.set_major_formatter(mticker.FuncFormatter(format_with_commas))
+    ax.set_xlim(np.min(x_lower), np.max(x_higher))
+    ax.set_xlabel(xlabel)
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
+    ax.set_title(title)
+    if legends:
+        plt.legend(labels=legends)
+    st.pyplot(fig)
+
+
+def generate_combinations_and_calculate_npv(
+        n_combinations,
+        model,
+        mortgage_interest_annual_list=[0.05],
+        property_price_growth_annual_list=[0.026],
+        rent_increase_list=[0.01325],
+        investment_return_annual_list=[0.06],
+        years_until_sell_list=[20]
+        ):
+        buying_npv_list = []
+        buying_fv_list = []
+        renting_fv_list = []
+        mortgage_interest_annual_list_chosen=[]
+        property_price_growth_annual_list_chosen=[]
+        rent_increase_list_chosen=[]
+        investment_return_annual_list_chosen=[]
+        years_until_sell_list_chosen=[]
+        adjust_for_inflation_bool = st.toggle('Adjust for inflation (2% a year)')
+        # use_present_value = st.toggle('Use present value instead of future value')
+
+        for n in range(n_combinations):
+
+                model.rent_increase = np.random.choice(rent_increase_list)
+                model.property_price_growth_annual = np.random.choice(property_price_growth_annual_list)
+                model.mortgage_interest_annual = np.random.choice(mortgage_interest_annual_list)
+                model.investment_return_annual = np.random.choice(investment_return_annual_list)
+                model.years_until_sell = np.random.choice(years_until_sell_list)
+                
+                model.run_calculations(adjust_for_inflation_bool = adjust_for_inflation_bool)
+                buying_npv_list.append(model.buying_npv)
+                buying_fv_list.append(model.buying_fv)
+                renting_fv_list.append(model.renting_fv)
+                mortgage_interest_annual_list_chosen.append(model.mortgage_interest_annual)
+                property_price_growth_annual_list_chosen.append(model.property_price_growth_annual)
+                rent_increase_list_chosen.append(model.rent_increase)
+                investment_return_annual_list_chosen.append(model.investment_return_annual)
+                years_until_sell_list_chosen.append(model.years_until_sell)
+        model.rent_increase = np.median(rent_increase_list)
+        model.property_price_growth_annual =  np.median(property_price_growth_annual_list)
+        model.mortgage_interest_annual =  np.median(mortgage_interest_annual_list)
+        model.investment_return_annual =  np.median(investment_return_annual_list)
+        model.years_until_sell =  int(np.median(years_until_sell_list))
+        model.run_calculations(adjust_for_inflation_bool = adjust_for_inflation_bool)
+
+        results_dict = {'buying_npv':buying_npv_list,
+                        'mortgage_interest_annual':mortgage_interest_annual_list_chosen,
+                        'property_price_growth_annual':property_price_growth_annual_list_chosen,
+                        'rent_increase':rent_increase_list_chosen,
+                        'investment_return_annual':investment_return_annual_list_chosen,
+                        'years_until_sell':years_until_sell_list_chosen}
+        results_df = pd.DataFrame(results_dict)
+        percentiles_df = calculate_percentiles(buying_npv_list,model.DEPOSIT)
+        # st.write(f'Capital Invested: £{model.DEPOSIT:.2f}')
+        # st.write(f'Assumed Monthly Rent: £{model.monthly_rent:.2f}')
+        # st.write(f'NPV mean: £{np.mean(buying_npv_list):.2f}')
+        # st.write(f'NPV mean (as % of invested capital): {np.mean(buying_npv_list)/model.DEPOSIT*100:.2f}%')
+        # st.write(f'NPV std: £{np.std(buying_npv_list):.2f}')
+        # st.write(f'NPV std (as % of invested capital): {np.std(buying_npv_list)/model.DEPOSIT*100:.2f}%')
+        # st.write(f'NPV skew: {skew(buying_npv_list):.2f}')
+        if model.buying_fv > model.renting_fv:
+            text="Under current assumptions, return is typically higher if you <strong>buy</strong>."
+        else:
+            text="Under current assumptions, return is typically higher if you <strong>rent and invest the deposit</strong>."
+        st.markdown(f'<p style="background-color:#F0F2F6;font-size:32px;border-radius:0%; font-style: italic;">{text}</p>', unsafe_allow_html=True)
+        # st.markdown(f'**<span style="font-size: 32px; font-style: italic;">{text}</span>**', unsafe_allow_html=True)
+        left_column, right_column = st.columns(2)
+        with right_column:
+            st.write(f"### Buy - Asset future value after {model.years_until_sell} years")
+            st.markdown(f"**Typical Total Asset Value: £{model.buying_fv:,.0f}**", help="All components are converted to future value at the time of sale.")
+            # right_column.markdown(f"***Breakdown:***")
+            with st.expander("***Breakdown***:", expanded=False):
+                st.markdown(f" - Capital Invested (deposit): £{model.DEPOSIT:,.0f}")
+                st.markdown(f" - Capital Invested (buying cost + stamp duty, if any): £{model.BUYING_COST_FLAT + model.STAMP_DUTY:,.0f}")        
+                st.markdown(f" - Property Price at Sale: :green[£{model.future_house_price:,.0f}]", help="Calculated using the property price growth rate set in the left sidebar.")
+                st.markdown(f" - Selling cost (including Capital Gains Tax): :red[ -£{model.SELLING_COST:,.0f}]",help= "Total expenses incurred when selling a property. These costs typically include real estate agent commissions, legal fees, advertising expenses, and any necessary repairs or renovations to prepare the property for sale.")
+                st.markdown(f" - Total maintenance and service costs: :red[ -£{model.fv_ongoing_cost:,.0f}]",help="Future value at the time of sale for the total cost associated with maintaining and servicing a property, including expenses such as property management fees, maintenance fees, and other related charges. Assumed to grow at inflation rate. Future value is determined by the discount rate, which is assumed to be equal to the investment return.")
+                st.markdown(f" - Total Mortgage Payments: :red[ -£{model.fv_mortgage_payments:,.0f}]", help="This is higher than the sum of all mortgage payments since the payments are converted to their future value at the time of sale. Future value is determined by the discount rate, which is assumed to be equal to the investment return.")
+                st.markdown(f" - Total Rent Saved (future value at time of sale): :green[£{model.rent_fv:,.0f}]", help="This is higher than the sum of all rent payments that would have been paid since the payments are converted to their future value at the time of sale. Future value is determined by the discount rate, which is assumed to be equal to the investment return.")
+        
+        with left_column:
+            st.write(f"### Rent and invest - Asset future value after {model.years_until_sell} years")
+            # plot_kde_from_list(renting_fv_list, left_column, figsize=(5, 2), title = 'Asset Value Probability Distribution', xlabel = 'Asset Value')
+            st.markdown(f"**Typical Total Asset Value: £{model.renting_fv:,.0f}**", help="All components are converted to future value at the time of sale.")
+            with st.expander("***Breakdown***:", expanded=False):
+                st.markdown(f" - Capital Invested (deposit): £{model.DEPOSIT:,.0f}")
+                st.markdown(f" - Capital Invested (buying cost + stamp duty, if any): £{model.BUYING_COST_FLAT + model.STAMP_DUTY:,.0f}")    
+                st.markdown(f" - Capital Gains Tax: :red[-£{model.cgt_investment:,.0f}]", help='Your tax rate is determined by the annual salary set in the left sidebar.')
+                if model.renting_fv - (model.DEPOSIT + model.BUYING_COST_FLAT + model.STAMP_DUTY) >= 0:
+                    st.markdown(f" - Assumed Typical Capital Growth: :green[£{model.renting_fv - (model.DEPOSIT + model.BUYING_COST_FLAT + model.STAMP_DUTY):,.0f}]", help="Calculated with the investment return rated provided in the left sidebar.")
+                else:
+                    st.markdown(f" - Assumed Typical Capital Growth: :red[£{model.renting_fv - (model.DEPOSIT + model.BUYING_COST_FLAT + model.STAMP_DUTY):,.0f}]")
+        st.write('---')
+        plot_kde_from_list([buying_fv_list,renting_fv_list], st, figsize=(7, 2), legends = ['Buying', 'Renting'],main_colors = ['orange', 'blue'], title = 'Future Asset Value Probability Distribution', xlabel = 'Asset Value')
+        plot_kde_from_list([buying_npv_list], st, legends = ['Buying is better', 'Renting is better'],main_colors = ['blue'], secondary_color = 'orange', title = 'Net Present Value Probability Distribution', xlabel = 'Net Present Value For Property Purchase')
+        st.markdown("<span style='font-size: 14px; font-style: italic;'>Net Present Value represents the net gain/loss that result in purchasing the property in present value. If it is positive, then it is financially better to buy a property. Present value is calculated using a future discount rate equal to your assumed investment return. This is equivalent to assuming that any amount you save on rent or mortgage will be invested. </span>", unsafe_allow_html=True)
+        # st.write("### Net Present Value Statistics")
+        with st.expander("### Net Present Value Statistics", expanded=False):
+            st.write(f'- Buying is better {100-percentiles_df.loc[5,"Percentile"]:.0f}% of the time')
+            st.write(f"- Mean: £{np.mean(buying_npv_list):,.0f}")
+            st.write(f"- Mean (as % of deposit): {np.mean(buying_npv_list)/model.DEPOSIT*100:.0f}%")
+            st.write(f"- Standard Deviation: £{np.std(buying_npv_list):,.0f}")
+            st.write(f"- Standard Deviation (as % of deposit): {np.std(buying_npv_list)/model.DEPOSIT*100:.0f}%")
+            st.write(f"- Skew: {skew(buying_npv_list):.2f}")
+        return percentiles_df, results_df
+
+def graph_kde_plots(results_df, FEATURES, num_cols = 2):
+    
+    # Calculate the number of rows and columns needed for subplots
+    num_features = len(FEATURES)
+    
+    num_rows = (num_features + num_cols - 1) // num_cols
+
+    # Create a figure and axis for subplots
+    fig, axes = plt.subplots(num_rows, num_cols, figsize=(15, 5 * num_rows))
+
+    # Flatten the axes if necessary (in case there's only one row)
+    if num_rows == 1:
+        axes = axes.reshape(1, -1)
+
+    # Loop through each feature and plot it
+    for i, feature in enumerate(FEATURES):
+        row = i // num_cols
+        col = i % num_cols
+        ax = axes[row, col]
+        
+        sns.kdeplot(data=results_df, x=feature, y="buying_npv", bw_adjust = 2, ax=ax, fill=True)
+        ax.set_title(f"{feature} vs. buying_npv")
+        ax.set_ylabel("buying_npv")
+        ax.set_xlabel(feature)
+         # Calculate the 95th percentile for x and y axes
+        x_low_percentile = np.percentile(results_df[feature], 0.1)
+        y_low_percentile = np.percentile(results_df['buying_npv'], 0.1)
+        x_high_percentile = np.percentile(results_df[feature], 99.9)
+        y_high_percentile = np.percentile(results_df['buying_npv'], 99.9)
+        
+        # Set the axis limits based on the 95th percentile
+        ax.set_xlim(x_low_percentile, x_high_percentile)
+        ax.set_ylim(y_low_percentile, y_high_percentile)
+        ax.yaxis.set_major_formatter(mticker.FuncFormatter(format_with_commas))
+    
+        # ax.set_xticklabels(ax.get_xticklabels(), rotation=45)  # Adjust the rotation angle as needed
+        
+    # Remove any empty subplots
+    for i in range(len(FEATURES), num_rows * num_cols):
+        fig.delaxes(axes.flatten()[i])
+
+    # Adjust spacing between subplots
+    plt.tight_layout()
+
+    # Show the plots
+    plt.show()
+    st.pyplot(fig)

src/utils/finance.py

@@ -0,0 +1,27 @@
+def get_stamp_duty_next_home(HOUSE_PRICE):
+    if HOUSE_PRICE <=250000:
+        return 0
+    elif HOUSE_PRICE <=925000:
+        return (HOUSE_PRICE-250000) * 0.05
+    elif HOUSE_PRICE <=1500000:
+        return (HOUSE_PRICE-925000) * 0.10 + (925000-250000) * 0.05
+    else:
+        return (HOUSE_PRICE-1500000) * 0.12 + (925000-250000) * 0.05 + (1500000-925000) * 0.10
+    
+def annuity_pv(payment, discount_rate, n_periods, growth_rate):
+    pv = payment * (1- (1+growth_rate)**n_periods*(1+discount_rate)**(-1*n_periods)) / (discount_rate-growth_rate)
+    return pv
+
+def annuity_fv(payment, discount_rate, n_periods, growth_rate, adjust_for_inflation = 0):
+    fv = payment * ((1+discount_rate)**n_periods - (1+growth_rate)**n_periods) / (discount_rate-growth_rate)
+    return fv / float(1+adjust_for_inflation)**(n_periods)
+
+def annuity_payment(pv, discount_rate, n_periods, growth_rate):
+    return pv* (discount_rate - growth_rate) / (1- (1+growth_rate)**n_periods * (1+discount_rate)**(-1*n_periods))
+
+
+def pv_future_payment(payment, discount_rate, n_periods):
+    return payment/(1+discount_rate)**(n_periods)
+
+def fv_present_payment(payment, discount_rate, n_periods, adjust_for_inflation = 0):
+    return payment*(1+discount_rate)**(n_periods) / float(1+adjust_for_inflation)**(n_periods)

src/utils/general.py

@@ -0,0 +1,78 @@
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import pandas as pddef 
+import matplotlib.pyplot as plt
+import streamlit as st
+def calculate_percentiles(arr, capital_invested):
+    """
+    Calculate the 10th, 25th, 50th (median), 75th, 90th, and the percentile of the value closest to 0 in an array.
+    Also, add a column that represents the values as a percentage of capital invested.
+
+    Args:
+    arr (list or numpy.ndarray): Input array.
+    capital_invested (float): The amount of capital invested.
+
+    Returns:
+    pandas.DataFrame: A DataFrame with percentiles and value as a percentage of capital invested.
+    """
+    if not isinstance(arr, (list, np.ndarray)):
+        raise ValueError("Input must be a list or numpy.ndarray")
+
+    percentiles = [10, 25, 50, 75, 90]
+    percentile_values = np.percentile(arr, percentiles)
+
+    # Find the value closest to 0
+    closest_value = min(arr, key=lambda x: abs(x - 0))
+
+    # Calculate the percentile of the closest value
+    sorted_arr = np.sort(arr)
+    index_of_closest = np.where(sorted_arr == closest_value)[0][0]
+    closest_percentile = (index_of_closest / (len(sorted_arr) - 1)) * 100
+
+    # Create the DataFrame with the "Value as % of Capital" column
+    data = {
+        'Percentile': percentiles + [closest_percentile],
+        'NPV': np.append(percentile_values, closest_value)
+    }
+
+    df = pd.DataFrame(data)
+    df['% return'] = (df['NPV'] / capital_invested) * 100
+
+    return df
+
+def bin_continuous_features(df, bin_config):
+    """
+    Encode continuous features into bins and add them as new columns to the DataFrame.
+
+    Parameters:
+    - df: pandas DataFrame
+        The DataFrame containing the continuous features.
+    - bin_config: dict
+        A dictionary specifying the binning configuration for each feature.
+        Example: {'feature1': [0, 10, 20, 30], 'feature2': [0, 5, 10]}
+
+    Returns:
+    - df: pandas DataFrame
+        The DataFrame with binned features added as new columns.
+    """
+
+    for feature, bins in bin_config.items():
+        # Create a new column with the binned values
+        df[f'{feature}_bin'] = pd.cut(df[feature], bins=bins, labels=False)
+
+    return df
+
+def get_param_distribution(mean, std, samples, bins,plot=True, as_int = False, title =''):
+    if std <=0:
+        return [mean]
+    s = np.random.normal(mean, std, samples)
+    if plot:
+        fig, ax = plt.subplots(figsize=(4, 1.7))
+        # plt.hist(s, bins, density=False)
+        sns.kdeplot(s,bw_adjust=5)
+        plt.title(title)
+        st.sidebar.pyplot(fig)
+    if as_int:
+        s=s.astype(int) 
+    return s