def create_final_table(growth_cf_part, growth_cf, shs_out, r_f_rate, req_return): final_table = growth_cf_part.copy() final_table['INTRINSIC VALUE'] = list( map(lambda i: np.npv(r_f_rate, [0] + extracted_cfs(i, growth_cf)), growth_cf.index)) final_table['BUY PRICE'] = list( map(lambda i: np.npv(req_return, [0] + extracted_cfs(i, growth_cf)), growth_cf.index)) final_table['I.V. / SHARE'] = final_table['INTRINSIC VALUE'] / shs_out final_table['B.P. / SHARE'] = final_table['BUY PRICE'] / shs_out return final_table
def bond_pricing(rate, r, n, M, m): ''' 债券定价 ------- Params rate: -> float 贴现率 r: -> float 年利息率 n: -> flaot 期限 M: -> float 票面金额 m: -> int 每年付息次数 Return price: -> float 债券价格 ''' global cash_flow # 计算贴现率 rate = rate / m # 计算每期利息率 r = r / m # 计算每期利息 C = M * r # 计算期数 n = n * m # 汇总现金流到一个list中 cash_flow = [0] + [C] * n price = npf.npv(rate, cash_flow) + M / (1 + rate)**n return price
def calculate_npv(self, rated_rpm_array, D_rotor_array, Power_rated_array, hub_height_array, water_depth_array, aep_array, cabling_cost=None): ''' Calculate Net Present Value [Euro] Input: rated_rpm_array [RPM] D_rotor_array [m] Power_rated_array [MW] hub_height_array [m] aep_array [kWh] water_depth_array [m] ''' self.calculate_expenditures(rated_rpm_array, D_rotor_array, Power_rated_array, hub_height_array, aep_array, water_depth_array, cabling_cost) self.calculate_cash_flow() self.NPV = npf.npv(self.discount_rate, self.CWF) return self.NPV
def calculate_price_lecture(B0, roe, Ke, shares, discount_factor, pos): if pos == -1 : years = 7 referenceDate = datetime(datetime.now().year+2,12,31) elif pos == -2 : years = 8 referenceDate = datetime(datetime.now().year+1,12,31) elif pos == -3 : years = 9 referenceDate = datetime(datetime.now().year,12,31) else : years = 10 referenceDate = datetime(datetime.now().year-1,12,31) Ke *= 0.01 roe *= 0.01 Bt = B0 excesses = [0,] excessRate = roe-Ke for i in range(years) : excessRate *= discount_factor roe = Ke + excessRate excess = Bt * roe - Bt * Ke excesses.append(excess) Bt += Bt * roe excessNetPresentValue = npf.npv(Ke,excesses) B = B0 + excessNetPresentValue priceAtThatTime = B/shares dayDifference = (referenceDate - datetime.now()).days price = priceAtThatTime / (1+Ke)**(dayDifference/365) return price
def test_npv_irr_congruence(self): # IRR is defined as the rate required for the present value of a # a series of cashflows to be zero i.e. NPV(IRR(x), x) = 0 cashflows = numpy.array([-40000, 5000, 8000, 12000, 30000]) assert_allclose(npf.npv(npf.irr(cashflows), cashflows), 0, atol=1e-10, rtol=0)
def calc_opex_annualized(OpC_USDyr, Inv_IR_perc, Inv_LT_yr): Inv_IR = Inv_IR_perc / 100 opex_list = [0.0] opex_list.extend(Inv_LT_yr * [OpC_USDyr]) opexnpv = npf.npv(Inv_IR, opex_list) EAC = ((opexnpv * Inv_IR) / (1 - (1 + Inv_IR)**(-Inv_LT_yr)) ) # calculate positive EAC return EAC
def get_profit(self, r, starch_price=320.36, ethanol_price=1.48, rp_price=351.05, p_credit=0.0, grain_product_index=1.0, rP_index=1.0, feedstock_index=1.0, chem_index=1.0, utility_index=1.0, tax=0.35): '''return net profit as annualized value, $/yr ''' revenue = self.get_revenue(starch_price=starch_price, ethanol_price=ethanol_price, p_credit=p_credit, rp_price=rp_price, grain_product_index=grain_product_index, rP_index=rP_index)[-1] cost = self.get_cost(feedstock_index=feedstock_index, chem_index=chem_index, utility_index=utility_index)[-1] taxable_income = revenue - cost net_profit = taxable_income * (1 - tax) # assume 40% as default tax if self.tech_GP == 1: direct_fixed_cost = self.df[self.column][12] # $/yr # depreciation_cost = self.df[self.column][16] # $/yr depreciation_cost = direct_fixed_cost * 0.0655 # $/yr elif self.tech_GP == 2: direct_fixed_cost = self.df[self.column][12] + self.df[ self.column][34] # $/yr # depreciation_cost = self.df[self.column][16] + self.df[self.column][38] # $/yr depreciation_cost = direct_fixed_cost * 0.0655 # $/yr working_capital = direct_fixed_cost * 0.05 # assume 5% cash_flow_list = [ -(direct_fixed_cost * tax + working_capital), -(direct_fixed_cost * (1 - tax)) ] for i in depreciation_rate: cash_flow_i = (revenue-(cost-depreciation_cost) - \ direct_fixed_cost*i)*(1-tax) + direct_fixed_cost*i cash_flow_list.append(cash_flow_i) npv = npf.npv(r, cash_flow_list) irr = npf.irr(cash_flow_list) annualized_value = npv / annuity_factor(20, r) a = [cost, revenue, taxable_income, net_profit] b = [ direct_fixed_cost, working_capital, depreciation_cost, cash_flow_list ] return a, b, irr, npv, annualized_value # wet_1 = Grain(plant_type=1, plant_capacity=5.0, tech_GP=2) # (Grain(plant_type=1, plant_capacity=2.1, tech_GP=2).get_energy_use()[-1] + \ # Grain(plant_type=1, plant_capacity=5.0, tech_GP=2).get_energy_use()[-1] + \ # Grain(plant_type=2, plant_capacity=120, tech_GP=2).get_energy_use()[-1])/(10**6)
def oekonomie_berechnen_gw_ve(leistung_pv, eco, kW, kalkulatorischer_zins, einspeiseverguetung_vektor): # Imports import numpy as np import numpy_financial as npf import copy # Berechnung kalkulatorischer_zins /= 100 summe_e_pv2g = np.sum(leistung_pv) / (60 * 1000) # Erloese aus den Energieflüssen einspeiseverguetung = (np.minimum(10, kW) / kW * (einspeiseverguetung_vektor[0]/100) \ + np.minimum(30, kW - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[1]/100) \ + np.minimum(60, kW - np.minimum(30, kW - np.minimum(10, kW) ) - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[2]/100)) ersparnis_pv2g = summe_e_pv2g * einspeiseverguetung # Gewinn 20 Jahre gewinn_pv_20 = np.zeros(20) gewinnkurve = np.zeros(21) gewinnkurve[0] = np.round(-1 * eco["invest"], 0) stromgestehung_zaehler = np.zeros(20) stromgestehung_nenner = np.zeros(20) for n in range(20): if n > 0: eco["betrieb"] += eco["betrieb"] * kalkulatorischer_zins gewinn_pv_20[n] = ersparnis_pv2g - eco["betrieb"] gewinnkurve[n + 1] = gewinnkurve[n] + gewinn_pv_20[n] #Stromgestehungskosten Zaehler und Nenner if n == 0: stromgestehung_zaehler[n] = (eco["invest"] + eco["betrieb"]) / ( (1 + kalkulatorischer_zins)**n) stromgestehung_nenner[n] = summe_e_pv2g / ( (1 + kalkulatorischer_zins)**n) gewinn_nettobarwert = np.concatenate([[gewinnkurve[0]], gewinn_pv_20]) nettobarwert = np.round( npf.npv(kalkulatorischer_zins, gewinn_nettobarwert), 0) if kW == 0: rendite = 0 nettobarwert = 0 else: rendite = np.round( npf.irr(np.concatenate([[gewinnkurve[0]], gewinn_pv_20])), 2) rendite *= 100 #Stromgestehungskosten zaehler = np.sum(stromgestehung_zaehler) nenner = np.sum(stromgestehung_nenner) stromgestehungskosten = np.round((zaehler / nenner) * 100, 1) return nettobarwert, rendite, gewinnkurve, stromgestehungskosten
def get_crop_cost_acf(self, r=0.07): '''return $/yr''' corn_cost = get_crop_cost('corn', self.landuse_matrix)[1] soybean_cost = get_crop_cost('soybean', self.landuse_matrix)[1] sg_cost = get_crop_cost('switchgrass', self.landuse_matrix)[1] crop_cost = corn_cost + soybean_cost + sg_cost npv = npf.npv(r, crop_cost) annualized_value = npv / annuity_factor(16, r) return crop_cost, annualized_value
def build_sensitivity_results(self, results_df): for index, row in results_df.iterrows(): processed_cashflows = self.build_cashflows(row["R_AdjustFact"], row["E_AdjustFact"], row["FCI_AdjustFact"]) cashflow_arr = np.array(processed_cashflows[Cash_flow]) NPV = round(np_fi.npv(self.i, cashflow_arr), 2) IRR = round(np_fi.irr(cashflow_arr), 4) results_df.loc[index, 'NPV'] = NPV results_df.loc[index, 'IRR'] = IRR return results_df
def test_npv_broadcast(self): cashflows = [ [-15000, 1500, 2500, 3500, 4500, 6000], [-15000, 1500, 2500, 3500, 4500, 6000], [-15000, 1500, 2500, 3500, 4500, 6000], [-15000, 1500, 2500, 3500, 4500, 6000], ] expected_npvs = [122.8948549, 122.8948549, 122.8948549, 122.8948549] actual_npvs = npf.npv(0.05, cashflows) assert_allclose(actual_npvs, expected_npvs)
def soln_net_present_value(self): """Marginal First Cost. SolarPVUtil 'Operating Cost'!E126:E250 """ npv = [] net_cash_flow = self.soln_net_cash_flow() for n in range(len(net_cash_flow.index)): l = [0] * (n + 1) + [net_cash_flow.iloc[n]] npv.append(numpy_financial.npv(rate=self.ac.npv_discount_rate, values=l)) result = pd.Series(npv, index=net_cash_flow.index) result.name = 'soln_net_present_value' return result
def soln_only_single_iunit_npv(self): """Net Present Value of single iunit cashflow, looking only at costs of the Solution. SolarPVUtil 'Operating Cost'!N126:N250 """ npv = [] sosic = self.soln_only_single_iunit_cashflow() offset = self.single_iunit_purchase_year - sosic.first_valid_index() + 1 for n in range(len(sosic.index)): l = [0] * (n + offset) + [sosic.iloc[n]] npv.append(numpy_financial.npv(rate=self.ac.npv_discount_rate, values=l)) result = pd.Series(npv, index=sosic.index.copy()) result.name = 'soln_only_single_iunit_npv' return result
def net_present_value_report(self, pro_forma): """ Uses the discount rate to calculate the present value for each column within the proforma Args: pro_forma (DataFrame): Pro-forma DataFrame that was created from each ValueStream or DER active """ # use discount rate to calculate NPV for net npv_dict = {} # NPV for growth_cols for col in pro_forma.columns: if col == 'Yearly Net Value': npv_dict.update({ 'Lifetime Present Value': [npf.npv(self.npv_discount_rate, pro_forma[col].values)] }) else: npv_dict.update({ col: [npf.npv(self.npv_discount_rate, pro_forma[col].values)] }) self.npv = pd.DataFrame(npv_dict, index=pd.Index(['NPV']))
def presentValue(self): # presentValue = (self.cashflow/((1 + self.discount) ** self.year)) # print(self.year,"년에 대한" ,"현재 자산가지 :", presentValue) # 1. 세부 지표 값 구하기 loss = [-750, -250] profit = [100] * 18 cf = loss + profit cashflow = np.array(cf) # 2. 순현재가치(NPV)와 내부수익률(IRR) 구하기 npv = npf.npv(0.045, cashflow) irr = npf.irr(cashflow) print("순현재가치(npv) : ", npv, "내부수익률(irr) : ", irr)
def summary(self): """ Calculate some quick summary numbers for the village. Returns ------- results : dict Dict of summary results. """ count_nodes = 0 income_per_month = 0 gen_size_kw = 0 for node in self.nodes: if node["conn"] == 1: count_nodes += 1 income_per_month += (node["area"] * self.num_people_per_m2 * self.demand * self.tariff) gen_size_kw += (node["area"] * self.num_people_per_m2 * self.demand_per_person_kw_peak) if self.origin: count_nodes -= 1 # so we don't count the generator total_length = 0.0 for arc in self.network: if arc["enabled"] == 1: total_length += arc["len"] capex = (gen_size_kw * self.gen_cost + self.cost_connection * count_nodes + self.cost_wire * total_length) opex = self.opex_ratio * capex income = income_per_month * 12 flows = np.ones(self.years) * (income - opex) flows[0] = -capex npv = npf.npv(self.discount_rate, flows) self.results = { "connected": count_nodes, "gen-size": int(gen_size_kw), "line-length": int(total_length), "capex": int(capex), "opex": int(opex), "income": int(income), "npv": int(npv), } return self.results
def cost_benefit_report(self, pro_forma): """ Calculates and returns a cost-benefit data frame Args: pro_forma (DataFrame): Pro-forma DataFrame that was created from each ValueStream or DER active """ # remove 'Yearly Net Value' from dataframe before preforming the rest (we dont want to include net values, so we do this first) pro_forma = pro_forma.drop('Yearly Net Value', axis=1) # prepare for cost benefit cost_df = pd.DataFrame(pro_forma.values.clip(max=0)) cost_df.columns = pro_forma.columns benefit_df = pd.DataFrame(pro_forma.values.clip(min=0)) benefit_df.columns = pro_forma.columns cost_pv = 0 # cost present value (discounted cost) benefit_pv = 0 # benefit present value (discounted benefit) self.cost_benefit = pd.DataFrame({'Lifetime Present Value': [0, 0]}, index=pd.Index( ['Cost ($)', 'Benefit ($)'])) for col in cost_df.columns: present_cost = npf.npv(self.npv_discount_rate, cost_df[col].values) present_benefit = npf.npv(self.npv_discount_rate, benefit_df[col].values) self.cost_benefit[col] = [np.abs(present_cost), present_benefit] cost_pv += present_cost benefit_pv += present_benefit self.cost_benefit['Lifetime Present Value'] = [ np.abs(cost_pv), benefit_pv ] # Transforming cost_benefit df bc XENDEE asked us to. self.cost_benefit = self.cost_benefit.T
def get_nitrate_cost(self, r=0.07, chem_index=1.0, utility_index=1.0): ''' return total cost of nitrate removal facility: (year,days); N_EAC = $/yr ''' N_cost_capital = 633 # depreciation cost: $633/day: equivalent annual cost per day overhead_cost = 72 * self.get_nitrate_days() # $72/day in 2003 utility_cost = 900 * self.get_nitrate_days()*utility_index # $900/day labor_cost = 239 * self.get_nitrate_days() # $239/day in 2003 (4 hrs/day for operation hour and 2 hrs/day for maintenance labor) N_cost_chemical = self.get_nitrate_days() * self.get_nitrate_chemical()[0] * 0.089 * 2.20462 * chem_index # 0.089 $/lb in 2003, 1 kg = 2.20462 lb N_cost_op = N_cost_chemical + overhead_cost + utility_cost + labor_cost # (year, day) N_cost_total = N_cost_capital + N_cost_op # return cost as a numpy array: (year, month) N_npv = npf.npv(r, N_cost_total.sum(axis=1)) N_EAC = N_npv/annuity_factor(16, r) # 16 yrs return [N_EAC]
def NPV(rate: xl.Number, *values): """Calculates the net present value of an investment by using a discount rate and a series of future payments (negative values) and income (positive values). https://support.office.com/en-us/article/ npv-function-8672cb67-2576-4d07-b67b-ac28acf2a568 """ if not len(values): return xl.ValueExcelError('value1 is required') cashflow = list(filter(xl.is_number, xl.flatten(values))) if xl.COMPATIBILITY == 'PYTHON': return numpy_financial.npv(rate, cashflow) return sum([ float(val) * (1 + rate)**-(i + 1) for (i, val) in enumerate(cashflow) ])
def get_sediment_cost(self, r=0.07, chem_index=1.0): '''return chemical cost for sediment treatment as a numpy array: (year,month)''' polymer = (0.0062*self.NTU + 0.31)/1000 # kg/m3 alum = (0.3*self.NTU + 30.0)/1000 # kg/m3 # cost_alum = cost_inflation(cost=0.0787, cost_yr=2019, start_yr=2003) # 0.0787 $/lb # cost_polymer = cost_inflation(cost=1.26, cost_yr=2019, start_yr=2003) # 1.26 $/lb alum_cost = alum*self.flow*0.0787*2.20462*chem_index # 0.0787 $/lb, 1 kg = 2.20462 lb polymer_cost = polymer*self.flow*1.26*2.20462*chem_index # 1.26 $/lb, 1 kg = 2.20462 lb number_days = np.zeros(((self.year.size, self.month.size))) for i in range(self.year.size): for j in range(12): number_days[i,j] = monthrange(self.year[i], self.month[j])[1] sediment_cost = (alum_cost + polymer_cost) * number_days # discount cash flow analysis sediment_cost_PV = npf.npv(r, sediment_cost.sum(axis=1)) sediment_EAC = sediment_cost_PV/annuity_factor(16, r) # 16 yrs return [sediment_EAC]
def get_crop_revenue_acf(self, r=0.07, crop_index=1.0): '''return $/yr''' corn_production = get_yield_crop('corn', self.landuse_matrix)[1].sum( axis=1) # kg/yr, (yr,) soybean_production = get_yield_crop('soybean', self.landuse_matrix)[1].sum( axis=1) # kg/yr, (yr,) sg_production = get_yield_crop( 'switchgrass', self.landuse_matrix)[1].sum(axis=1) # kg/yr, (yr,) # production = [corn_production, soybean_production, sg_production] corn_revenue = corn_production * self.corn_price * crop_index # corn_price = $0.152/kg soybean_revenue = soybean_production * self.soybean_price * crop_index # soybean_price = $0.356/kg sg_revenue = sg_production * self.sg_price * 0.8 * crop_index # sg_price = $0.04/kg, 80% moisture total_revenue = corn_revenue + soybean_revenue + sg_revenue npv = npf.npv(r, total_revenue) annualized_value = npv / annuity_factor(16, r) return corn_revenue, soybean_revenue, sg_revenue, total_revenue, annualized_value
def rim(roe, equity, 지속계수): Y10 = { '초과이익률': [roe - 요구수익률, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'ROE': [roe, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], '순이익': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], '자본': [equity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], '초과이익': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], } for i in range(1, 11): Y10['초과이익률'][i] = Y10['초과이익률'][i - 1] * 지속계수 Y10['ROE'][i] = 요구수익률 + Y10['초과이익률'][i] Y10['순이익'][i] = Y10['자본'][i - 1] * Y10['ROE'][i] Y10['자본'][i] = Y10['자본'][i - 1] + Y10['순이익'][i] Y10['초과이익'][i] = Y10['순이익'][i] - (Y10['자본'][i - 1] * 요구수익률) 순현재가치 = npf.npv(요구수익률, Y10['초과이익']) RIM주주가치 = 자본 + 순현재가치 RIM주당가치 = round(RIM주주가치 * 100000000 / 주식수) return RIM주당가치
def NPV( rate: xltypes.XlNumber, *values: Tuple[xltypes.XlNumber], ) -> xltypes.XlNumber: """Calculates the net present value of an investment by using a discount rate and a series of future payments (negative values) and income (positive values). https://support.office.com/en-us/article/ npv-function-8672cb67-2576-4d07-b67b-ac28acf2a568 """ if not len(values): raise xlerrors.ValueExcelError('value1 is required') cashflow = [float(value) for value in values] rate = float(rate) if xl.COMPATIBILITY == 'PYTHON': return numpy_financial.npv(rate, cashflow) return sum( [val * (1 + rate)**-(i + 1) for (i, val) in enumerate(cashflow)])
def annuity_scalar(self, opt_years): """Calculates an annuity scalar, used for sizing, to convert yearly costs/benefits this method is sometimes called before the class is initialized (hence it has to be static) Args: opt_years (list): List of years that the user wants to optimize--should be length=1 Returns: the NPV multiplier """ n = self.end_year.year - self.start_year.year dollar_per_year = np.ones(n) base_year = min(opt_years) yr_index = base_year - self.start_year.year while yr_index < n - 1: dollar_per_year[yr_index + 1] = dollar_per_year[yr_index] * (1 + self.inflation_rate) yr_index += 1 yr_index = base_year - self.start_year.year while yr_index > 0: dollar_per_year[yr_index - 1] = dollar_per_year[yr_index] * (1 / (1 + self.inflation_rate)) yr_index -= 1 lifetime_npv_alpha = npf.npv(self.npv_discount_rate, [0] + dollar_per_year) return lifetime_npv_alpha
def discount_factor(iy, n): disc = 1 / (1 + iy)**n print(str(round(disc, 5)), ' discount factor') TVM.compound_int(n=2, iy=.05, pv=100) TVM.future_value(n=2, iy=.05, pv=100) TVM.discount_factor(n=2, iy=.05) inv = npf.pv(rate=.05, nper=10, pmt=0, fv=100000) investment_2 = npf.fv(rate=.08, nper=10, pmt=0, pv=-100000) print("Investment 2 will yield a total of $" + str(round(investment_2, 2)) + " in 10 years") print(inv) # Calculate investment_3 investment_3 = npf.fv(rate=.08, nper=10, pmt=0, pv=-100000) print("Investment 3 will yield a total of $" + str(round(investment_3, 2)) + " in 10 years") # Calculate investment_3 and adjsut for inflation of 3% investment_3_discounted = npf.pv(rate=.03, nper=10, pmt=0, fv=investment_3) print("After adjusting for inflation, investment 3 is worth $" + str(round(-investment_3_discounted, 2)) + " in today's dollars") #Discounting cashflows with NPV # NPV = sum of all discounted cashflows cashflows = np.array([100, 100, 100, 100, 100]) npvinv1 = npf.npv(rate=.03, values=cashflows) print('NPV of INV1 is $', str(round(npvinv1, 2)) + " in today's dollars")
def financial_metrics(self, discount_rate): return irr(self.df.loc['Cash Flow']), npv(discount_rate, self.df.loc['Cash Flow'])
def oekonomie_berechnen_ms(leistung_pv, leistung_last, eco, kW, mieterstrom_zuschlag, kalkulatorischer_zins, betreiber, einspeiseverguetung_vektor): # Imports import numpy as np import numpy_financial as npf # Variablen statt festen Werten dt_min = 60 # Zeitschrittweite in Minuten # Berechnung kalkulatorischer_zins /= 100 # Prozent in dezimal e_pv2l = np.minimum(leistung_pv, leistung_last) # in Watt! e_pv2g = leistung_pv - e_pv2l # in Watt! # Grid to load e_g2l = leistung_last - leistung_pv # in Watt! e_g2l[e_g2l <= 0] = 0 # in Watt! # Energiesummen summe_e_g2l = np.sum(e_g2l) / (dt_min * 1000 ) # Wattminuten in kWh umgerechnet summe_e_pv2l = np.sum(e_pv2l) / (dt_min * 1000) # in kWh summe_e_pv2g = np.sum(e_pv2g) / (dt_min * 1000) # in kWh summe_pvs = np.sum(leistung_pv) / (dt_min * 1000) # in kWh summe_last = np.sum(leistung_last) / (dt_min * 1000) # in kWh # Eigenverbrauchsanteil Eigenverbrauchsanteil = np.round((summe_e_pv2l / summe_pvs) * 100, 1) # Autarkiegrad Autarkiegrad = np.round((summe_e_pv2l / summe_last) * 100, 1) # Erloese aus den Energieflüssen einspeiseverguetung = (np.minimum(10, kW) / kW * (einspeiseverguetung_vektor[0]/100) \ + np.minimum(30, kW - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[1]/100) \ + np.minimum(60, kW - np.minimum(30, kW - np.minimum(10, kW) ) - np.minimum(10, kW)) / kW * (einspeiseverguetung_vektor[2]/100)) einspeiseverguetung -= 0.004 # Marktprämie abziehen ersparnis_pv2g = summe_e_pv2g * einspeiseverguetung # Gewinn 20 Jahre gewinn_pv_20 = np.zeros(20) gewinnkurve = np.zeros(21) gewinnkurve[0] = np.round(-1 * eco["invest"], 0) # Mieterstromzuschlag if mieterstrom_zuschlag == 'Ja': if kW < 40: # Zuschlag berechnen nach: für erste 40kW -8,5 ct, für danach nur -8,0 ct bis 750 kW c_mieterstromzuschlag = summe_e_pv2l * \ np.maximum((einspeiseverguetung - 0.085),0) else: c_mieterstromzuschlag = summe_e_pv2l * \ np.maximum((einspeiseverguetung - 0.08),0) else: c_mieterstromzuschlag = 0 C_Verwaltung = 100 / 1.19 # Euro pro Jahr und Teilnehmer # Rolle und die damit verbundenen Kosten if betreiber == 'betreiber-0': c_pacht = 0 else: c_pacht = kW * 150 / 20 stromgestehung_zaehler = np.zeros(20) stromgestehung_nenner = np.zeros(20) # Berechnung über 20 Jahre: for n in range(20): if n > 0: # Achtung, hier werden die aus eco_vorbereiten stammenden Werte überschrieben mit Inflation eco["betrieb"] += eco["betrieb"] * kalkulatorischer_zins eco["grundpreis"] += eco["grundpreis"] * kalkulatorischer_zins # Annahme, damit der Mieterstrom vermarktet werden kann. c_Mieterstrompreis = 0.9 * eco["strompreis_vektor"][n] # Bonusberechnung (nicht in Oekonomie_berechnen_MS_JB): lcoe #Stromgestehungskosten Zaehler und Nenner if n == 0: stromgestehung_zaehler[n] = (eco["invest"] + eco["betrieb"]) / ( (1 + kalkulatorischer_zins)**n) else: #! die Betriebskosten muss ich doch auch jährlich abzinsen! stromgestehung_zaehler[n] = (eco["betrieb"]) / ( (1 + kalkulatorischer_zins)**n) stromgestehung_nenner[n] = summe_pvs / ((1 + kalkulatorischer_zins)**n) # Ende lcoe # Zusammenrechnen der Kosten kosten_mieterstrom = -1 * summe_e_g2l*1*c_Mieterstrompreis / 1.19 \ - eco["betrieb"] /1.19 - eco["umlage"][n]*summe_e_pv2l - \ C_Verwaltung*eco["i_teilnehmer"] - c_pacht gewinne_mieterstrom = summe_last*1*c_Mieterstrompreis /1.19 \ + c_mieterstromzuschlag + ersparnis_pv2g \ + eco["grundpreis"] * eco["i_teilnehmer"] / 1.19 # Volleinspeisung vs. MS: gewinn_pv_20[n] = np.maximum(summe_pvs * einspeiseverguetung - eco["betrieb"] /1.19,\ gewinne_mieterstrom + kosten_mieterstrom) # Mieterstrom gewinnkurve[n + 1] = gewinnkurve[n] + gewinn_pv_20[n] # kumuliert # Schleifenende 20 Jahre gewinn_nettobarwert = np.concatenate([[gewinnkurve[0]], gewinn_pv_20]) nettobarwert = np.round( npf.npv(kalkulatorischer_zins, gewinn_nettobarwert), 0) if kW == 0: # warum fragen wir das ab?! rendite = 0 nettobarwert = 0 else: rendite = npf.irr(gewinn_nettobarwert) rendite = np.round(rendite * 100, 2) #BS: soweit OK #Stromgestehungskosten zaehler = np.sum(stromgestehung_zaehler) nenner = np.sum(stromgestehung_nenner) stromgestehungskosten = np.round((zaehler / nenner) * 100, 1) return nettobarwert, rendite, gewinnkurve, Eigenverbrauchsanteil, Autarkiegrad, stromgestehungskosten
# Set the corporate tax rate tax_rate = 0.35 # Calculate the WACC wacc = percent_equity * cost_equity + percent_debt * cost_debt * (1 - tax_rate) print("WACC: " + str(round(100 * wacc, 2)) + "%") import numpy as np import numpy_financial as npf # Set your weighted average cost of capital equal to 12.9% wacc = 0.129 # Calculate the net present value for Project 1 npv_project1 = npf.npv(0.129, cf_project1) print("Project 1 NPV: " + str(round(npv_project1, 2))) # Calculate the net present value for Project 2 npv_project2 = npf.npv(0.129, cf_project2) print("Project 2 NPV: " + str(round(npv_project2, 2))) import numpy as np # Create a numpy array of cash flows for Project 1 cf_project_1 = np.array([-700, 100, 150, 200, 250, 300, 350, 400]) # Create a numpy array of cash flows for Project 2 cf_project_2 = np.array([-400, 50, 100, 150, 200, 250, 300]) # Scale the original objects by 1000x
# Calculate investment_2 investment_1_discounted = npf.pv(rate=0.03, nper=10, pmt=0, fv=21589.24997272788) print("After adjusting for inflation, investment 1 is worth $" + str(round(-investment_1_discounted, 2)) + " in today's dollars") import numpy as np import numpy_financial as npf # Predefined array of cash flows cash_flows = np.array([100, 100, 100, 100, 100]) # Calculate investment_1 investment_1 = npf.npv(rate=0.03, values=np.array([100, 100, 100, 100, 100])) print("Investment 1's net present value is $" + str(round(investment_1, 2)) + " in today's dollars") # Calculate investment_2 investment_2 = npf.npv(rate=0.05, values=np.array([100, 100, 100, 100, 100])) print("Investment 2's net present value is $" + str(round(investment_2, 2)) + " in today's dollars") # Calculate investment_3 investment_3 = npf.npv(rate=0.07, values=np.array([100, 100, 100, 100, 100])) print("Investment 3's net present value is $" + str(round(investment_3, 2)) + " in today's dollars") import numpy as np import numpy_financial as npf
def calc_dv01(rate, cashflows): # DV01: mudança esperada no valor presente para uma mudança de 1bp na taxa de juros return (abs(npf.npv(rate + 0.0001, cashflows)) + abs(npf.npv(rate - 0.0001, cashflows))) / 2