import pandas as pd
import matplotlib.pyplot as plt
 
# Constants
monthly_sip = 100000  # Monthly SIP amount in INR
inflation_rate = 0.15  # 15% annual inflation
tax_rate = 0.125  # LTCG Tax rate (12.5%)
rate_of_return_annual = 0.135  # 13.5% annual return
 
# Calculating monthly rate of return
rate_of_return_monthly = rate_of_return_annual / 12
 
# Function to calculate SIP corpus at the end of each year
def calculate_sip_corpus(P, i, n):
    """Calculate Future Value of SIP"""
    return P * (((1 + i) ** n - 1) / i) * (1 + i)
 
# Function to calculate inflated price of the item
def calculate_inflated_price(initial_price, inflation_rate, years):
    """Calculate the inflated price of the item"""
    return initial_price * ((1 + inflation_rate) ** years)
 
# Function to calculate taxable profits and LTCG tax
def calculate_taxable_profits_and_tax(total_sip_contributions, corpus, tax_rate):
    """Calculate taxable profits and LTCG tax"""
    profits = corpus - total_sip_contributions
    tax = profits * tax_rate
    post_tax_profits = profits - tax
    return profits, tax, post_tax_profits
 
# Initial values
initial_item_price = 15000000  # Initial item price in INR (1.5 crore)
total_sip_contributions = 0  # Total SIP contributions, initialized to zero
corpus = 0  # SIP corpus, initialized to zero
 
# Store results for each 5-year interval
output_data = []
 
# Simulating the SIP for 30 years
for year in range(5, 31, 5):
    # Number of months till the current 5-year period
    n_months = 12 * year
 
    # Calculate SIP corpus for this period
    corpus = calculate_sip_corpus(monthly_sip, rate_of_return_monthly, n_months)
 
    # Total SIP contributions are simply the SIP amount multiplied by the number of months
    total_sip_contributions = monthly_sip * n_months
 
    # Calculate the inflated price of the item after 'year' years
    inflated_price = calculate_inflated_price(initial_item_price, inflation_rate, year)
 
    # Calculate taxable profits, tax, and post-tax profits
    profits, tax, post_tax_profits = calculate_taxable_profits_and_tax(total_sip_contributions, corpus, tax_rate)
 
    # Prepare the output string in the desired format
    output_data.append({
        "Period": f"Year {year - 4} to {year}",
        "Contributed Amount Till Now": f"{total_sip_contributions / 1e7:.2f} Cr",
        "Profits Made Till Now": f"{profits / 1e7:.2f} Cr",
        "Total Taxes Till Now": f"{tax / 1e5:.2f} L",
        "Total Amount Available for Withdrawal": f"{post_tax_profits / 1e7:.2f} Cr",
        "Inflated Value of Asset": f"{inflated_price / 1e7:.2f} Cr"
    })
 
# Create a DataFrame to display the results
df_output = pd.DataFrame(output_data)
 
# Display the output for each 5-year period
print("SIP Investment Overview (Every 5 Years):")
for row in df_output.itertuples(index=False, name=None):
    print(f"\n{row[0]} --")
    print(f" - Contributed amount till now: {row[1]}")
    print(f" - Profits made from SIP till now: {row[2]}")
    print(f" - Total taxes paid (12.5% of profits): {row[3]}")
    print(f" - Total amount available for withdrawal: {row[4]}")
    print(f" - Inflated value of the asset at this time: {row[5]}")
 
# Plotting the data (optional)
plt.figure(figsize=(12, 8))
 
# Plot SIP Corpus vs Year
plt.plot(df_output['Period'], df_output['Total Amount Available for Withdrawal'], label='Total Amount Available for Withdrawal', marker='o', color='b')
 
# Adding title and labels
plt.title('Comparison of Total Amount Available for Withdrawal Over 30 Years')
plt.xlabel('Year Period')
plt.ylabel('Amount in INR')
 
# Show the plot
plt.grid(True)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
 

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