fin_recipes.h

Financial Recipes

// file: fin_recipes.h
// author: Bernt Arne Oedegaard
//   defines all routines in the financial numerical recipes "book"

#include <vector>
using namespace std;

///////// present value ////////////////////////////////////

double cash_flow_pv (const vector<double>& cflow_times, 
		     const vector<double>& cflow_amounts, double r);

double cash_flow_pv_discrete (const vector<double>& cflow_times, 
			      const vector<double>& cflow_amounts, double r);

double cash_flow_irr(const vector<double>& cflow_times, 
		     const vector<double>& cflow_amounts);

bool cash_flow_unique_irr(const vector<double>& cflow_times, 
			  const vector<double>& cflow_amounts);

double bonds_price(const vector<double>& coupon_times,
		   const vector<double>& coupon_amounts,
		   const vector<double>& principal_times, 
		   const vector<double>& principal_amounts, 
		   const double& r);

double bonds_price(const vector<double>& cashflow_times,
		   const vector<double>& cashflows,
		   const double& r);  

double bonds_price_discrete(const vector<double>& cashflow_times,
			    const vector<double>& cashflows,
			    const double& r);  

double bonds_duration(const vector<double>& cashflow_times,
		      const vector<double>& cashflows,
		      const double& r);

double bonds_yield_to_maturity( const vector<double>& cashflow_times, 
				const vector<double>& cashflow_amounts,
				const double& bondprice);

double bonds_duration_macaulay(const vector<double>& cashflow_times,
			       const vector<double>& cashflows,
			       const double& bond_price);

double bonds_duration_modified (const vector<double>& cashflow_times,
				const vector<double>& cashflow_amounts,
				const double& bond_price,
				const double& r);
 
double bonds_convexity(const vector<double>& cashflow_times,   
		       const vector<double>& cashflow_amounts,
		       const double& y );

/// term structure basics 

double term_structure_yield_from_discount_factor(double dfact, double t); 
double term_structure_discount_factor_from_yield(double r, double t);
double term_structure_forward_rate_from_disc_facts(double d_t, double d_T, double time);
double term_structure_forward_rate_from_yields(double r_t1, double r_T, double t1, double T);
double term_structure_yield_linearly_interpolated(double time, 
						  const vector<double>& obs_times, 
						  const vector<double>& obs_yields);

/// Black Scholes formula //////////////////////////////////////////

double option_price_call_black_scholes(double S, double X, double r, double sigma, double time) ;
double option_price_put_black_scholes (double S, double X, double r, double sigma, double time) ;

double option_price_implied_volatility_call_black_scholes_newton( double S, double X, double r, 
								  double time, double option_price);

double option_price_implied_volatility_call_black_scholes_bisections( double S, double X, double r, 
								      double time, double option_price);

double option_price_delta_call_black_scholes(double S, double X, double r, double sigma, double time);
double option_price_delta_put_black_scholes (double S, double X, double r, double sigma, double time);

void option_price_partials_call_black_scholes( double S, double X, double r, double sigma, double time, 
					       double& Delta, double& Gamma, double& Theta,
					       double& Vega, double& Rho);

void option_price_partials_put_black_scholes(double S, double X, double r, double sigma, double time,
					     double& Delta, double& Gamma, double& Theta, 
					     double& Vega, double& Rho);


/// Extensions of the Black Scholes model //////////////

double option_price_european_call_payout(double S, double X, double r, double b, double sigma, double time);
double option_price_european_put_payout (double S, double X, double r, double b, double sigma, double time);

double option_price_european_call_dividends(double S, double X, double r, double sigma, double time,
					    vector<double>& dividend_times, 
					    vector<double>& dividend_amounts );
double option_price_european_put_dividends( double S, double X, double r, double sigma,double time,
					    vector<double>& dividend_times, 
					    vector<double>& dividend_amounts);
double option_price_american_call_dividend( double S, double X, double r, double sigma,
					    double tau, double D1, double tau1);
double futures_option_price_call_european_black( double F, double X, double r, double sigma, double time);
double futures_option_price_put_european_black ( double F, double X, double r, double sigma, double time);
double currency_option_price_call_european( double S, double X, double r, double r_f, double sigma, double time);
double currency_option_price_put_european( double S, double X, double r, double r_f, double sigma, double time);

// binomial option approximation ////////////////

double option_price_call_european_binomial(double S, double X, double r, double sigma, double t, int steps);
double option_price_put_european_binomial (double S, double X, double r, double sigma, double t, int steps);

double option_price_call_american_binomial(double S, double X, double r, double sigma, double t, int steps);
double option_price_put_american_binomial (double S, double X, double r, double sigma, double t, int steps);

double option_price_call_american_binomial_payout(double S, double X, double r, double y,
						  double sigma, double t, int steps);
double option_price_put_american_binomial_payout (double S, double X, double r, double y,
						  double sigma, double t, int steps);
 
double option_price_call_american_discrete_dividends_binomial( double S, double X, double r,
							       double sigma,  double t, int steps, 
							       vector<double>& dividend_times,
							       vector<double>& dividend_amounts);

double option_price_put_american_discrete_dividends_binomial(double S, double X, double r, 
							     double sigma,  double t, int steps, 
							     vector<double>& dividend_times, 
							     vector<double>& dividend_amounts);

double option_price_call_american_proportional_dividends_binomial(double S, double X, double r,
								  double sigma, double time, int no_steps,
								  vector<double>& dividend_times,
								  vector<double>& dividend_yields);

double option_price_put_american_proportional_dividends_binomial( double S, double X, double r,
								  double sigma, double time, int no_steps,
								  vector<double>& dividend_times,
								  vector<double>& dividend_yields); 

double option_price_delta_american_call_binomial(double S, double X, double r,  
						 double sigma, double t, int no_steps);

double option_price_delta_american_put_binomial(double S, double X, double r,  
						double sigma, double t, int no_steps);

void option_price_partials_american_call_binomial(double S, double X, double r,    
						  double sigma, double time, int no_steps,
						  double& delta, double& gamma, double& theta,
						  double& vega, double& rho);  
 
void option_price_partials_american_put_binomial(double S, double X, double r,    
						 double sigma, double time, int no_steps,
						 double& delta, double& gamma, double& theta,
						 double& vega, double& rho);  

double futures_option_price_call_american_binomial(double F, double X, double r, double sigma,
						   double time, int no_steps);

double futures_option_price_put_american_binomial( double F, double X, double r, double sigma,
						   double time, int no_steps);

double currency_option_price_call_american_binomial( double S, double X, double r, double r_f, 
						     double sigma, double t, int n);

double currency_option_price_put_american_binomial( double S, double X, double r, double r_f,
						    double sigma, double t, int n);

//////////////////// finite differences //////////////////

double option_price_call_american_finite_diff_explicit( double S, double X, double  r,
							double sigma, double time, 
							int no_S_steps, int no_t_steps);

double option_price_put_american_finite_diff_explicit( double S, double X, double  r, 
						       double sigma, double time, 
						       int no_S_steps, int no_t_steps);

double option_price_call_european_finite_diff_explicit( double S, double X, double  r,
							double sigma, double time, 
							int no_S_steps, int no_t_steps);

double option_price_put_european_finite_diff_explicit( double S, double X, double  r, 
						       double sigma, double time, 
						       int no_S_steps, int no_t_steps);

double option_price_call_american_finite_diff_implicit( double S, double X, double r,
							double sigma, double time, 
							int no_S_steps, int no_t_steps);

double option_price_put_american_finite_diff_implicit( double S, double X, double r,
						       double sigma, double time, 
						       int no_S_steps, int no_t_steps);

double option_price_call_european_finite_diff_implicit( double S, double X, double r,
							double sigma, double time, 
							int no_S_steps, int no_t_steps);

double option_price_put_european_finite_diff_implicit( double S, double X, double r,
						       double sigma, double time, 
						       int no_S_steps, int no_t_steps);

///////////////////////// simulated option prices //////////////////////////////////////

double option_price_call_european_simulated(const double& S, const double& X,
					    const double& r, const double& sigma,
					    const double& time_to_maturity, const int& no_sims);

double option_price_put_european_simulated(const double& S, const double& X,
					   const double& r, const double& sigma,
					   const double& time_to_maturity, const int& no_sims);

double option_price_delta_call_european_simulated(const double& S, const double& X,
						  const double& r, const double& sigma,
						  const double& time_to_maturity, const int& no_sims);

double option_price_delta_put_european_simulated(const double& S, const double& X,
						 const double& r, const double& sigma,
						 const double& time_to_maturity, const int& no_sims);

double simulate_lognormal_random_variable(const double& S, const double& r, const double& sigma,
					  const double& time);

double 
derivative_price_simulate_european_option_generic( const double& S, const double& X,
						   const double& r, const double& sigma,
						   const double& time,
						   double payoff(const double& price,
								 const double& X),
						   const int& no_sims); 

double 
derivative_price_simulate_european_option_generic_with_control_variate(const double& S, const double& X,
								       const double& r,const double& sigma,
								       const double& time,
								       double payoff(const double& price,
										     const double& X),
								       const int& no_sims); 

double 
derivative_price_simulate_european_option_generic_with_antithetic_variate(const double& S, const double& X,
									  const double& r,
									  const double& sigma,
									  const double& time,
									  double payoff(const double&price,
											const double& X),
									  const int& no_sims); 

/////////// approximated option prices ////////////////////////

double option_price_american_call_approximated_baw(double S, double X, double r, double b, 
						   double sigma, double time);

double option_price_american_put_approximated_baw(double S, double X, double r, double b, 
						  double sigma, double time);


////////////// path dependent and other exotic options ////////////////////////////////

double option_price_european_lookback_call(const double& S, const double& Smin,  const double& r,
					   const double& q, const double& sigma,  const double& time);

double option_price_european_lookback_put(const double& S, const double& Smin, const double& r,
					  const double& q, const double& sigma, const double& time);


double 
option_price_asian_geometric_average_price_call(const double& S, const double& X, const double& r,
						const double& q, const double& sigma, const double& time);

vector<double> simulate_lognormally_distributed_sequence(double S, double r,  
							 double sigma, double time,  int no_steps);
double 
derivative_price_simulate_european_option_generic( const double& S, const double& X, const double& r, 
						   const double& sigma, const double& time,
						   double payoff(const vector<double>& price,
								 const double& X),
						   const int& no_steps, const int& no_sims); 


double 
derivative_price_simulate_european_option_generic_with_control_variate(const double& S, const double& X,
								       const double& r, const double& sigma,
								       const double& time,
								       double payoff(const vector<double>& price,
										     const double& X),
								       const int& nosteps, const int& nosims); 

double 
derivative_price_simulate_european_option_generic_with_antithetic_variate(const double& S, const double& X,
									  const double& r, const double& sigma,
									  const double& time,
									  double payoff(const vector<double>&price,
											const double& X),
									  const int& nosteps, const int& nosims); 

/////////////////// alternative stochastic processes ////////////////

double option_price_call_merton_jump_diffusion( double S, double X, double r, 
						double sigma, double time_to_maturity,
						double lambda, double kappa, double delta);

// fixed income derivatives,  Black Scholes bond option

double bond_option_price_call_zero_black_scholes(double B, double X, double r, double sigma, double time);
double bond_option_price_put_zero_black_scholes(double B, double X, double r, double sigma, double time);
double bond_option_price_call_coupon_bond_black_scholes(double B, double X, double r, 
							double sigma, double time, 
							vector<double> coupon_times, 
							vector<double> coupon_amounts);
double bond_option_price_put_coupon_bond_black_scholes(double B, double X, double r,
						       double sigma, double time, 
						       vector<double> coupon_times,
						       vector<double> coupon_amounts);

/// bond option,  rendlemann barterr  (binomial)

double bond_option_price_call_zero_american_rendleman_bartter(double X, double option_maturity,  double S, 
							      double M,  double interest, 
							      double bond_maturity,
							      double maturity_payment,
							      int no_steps);