/// <summary>
/// Generates new normal distribution settings as a sum of correlated normal distributions with coefficients <paramref name="coeffs"/> (c1*A+c2*B+c3*C etc.)
/// </summary>
/// <param name="coeffs">Coefficients vector that will be applied to the sum of normal distributions.</param>
/// <returns>Normal distribution settings instance.</returns>
public NormalDistributionSettings GetUnivariateDistributionSettings(double[] coeffs)
{
if (coeffs == null)
{
coeffs = Vector.Ones(Dimension);
}
if (coeffs.Length != Dimension)
{
throw new DistributionsArgumentException(DistributionsArgumentExceptionType.VectorOfCoeffitientsMustBeEqualToDimension);
}
if (coeffs.All(x => x == 1))
{
return(new NormalDistributionSettings(Means.Sum(), Math.Sqrt(CovarianceMatrix.Sum())));
}
double[,] ltf = Chol.LeftTriangularFactor;
var weighted = Matrix.Diagonal(coeffs).Dot(ltf);
var colSumPow = weighted.Transpose().Dot(Vector.Ones(Dimension)).Pow(2);
double variance = colSumPow.Sum();
double mean = Elementwise.Multiply(coeffs, Means).Sum();
return(new NormalDistributionSettings(mean, Math.Sqrt(variance)));
}
/// <summary>
/// Calculate the efficient frontier for a given covariance matrix and mean vector
/// </summary>
/// <param name="covariance">Covariance Matrix of assets included in portfolio</param>
/// <param name="mean">Expected return of assets in portfolio</param>
public IPortfolio Calculate()
{
// MVO using quadratic programming
// Optimal portfolio is:
// min(-dvec'bvec+1/2x'Dmat*x) - where ' is the transpose of vector/matrix
// Dmat - Covariance Matrix - quadratic terms
// dvec - [0..nAssets] - linear terms
// Amat - variable weigths in constraints equation
// bvec - constraint equalities
// with constraints
// A'x >= b
// meq = eqsumW
// Get mean returns of all instruments in portfolio
var meanReturns = from sp in _samplePortfolio
select sp.Mean;
// Get covariance matrix for all instruments in portfolio
var cov = from sp in _samplePortfolio
select new KeyValuePair <string, Dictionary <string, double> >(sp.ID, sp.Covariance);
var covariance = CovarianceMatrix.Create(cov.ToDictionary(a => a.Key, b => b.Value));
var portfConf = new ConfigurationManager(_samplePortfolio);
OptimizationResult result;
double[] dvec = new double[_samplePortfolio.Count].Zeros(_samplePortfolio.Count);
try
{
result = QuadProg.Solve(covariance, dvec, portfConf.Amat, portfConf.Bvec, portfConf.NumEquals);
}
catch (Exception e)
{
// Solution not found - create NaN Portfolio
result = new OptimizationResult(new double[] { double.NaN }, double.NaN);
// Log error
Console.WriteLine(e.Message);
}
int q = 0;
double sum = 0;
foreach (var m in meanReturns)
{
sum = sum + m * result.Solution[q];
q++;
}
var portf = PortfolioFactory.Create(_samplePortfolio, _samplePortfolio.Name, sum, result.Value);
for (int c = 0; c < result.Solution.Length; c++)
{
portf[_samplePortfolio[c].ID].Weight = result.Solution[c];
}
return(portf);
}
/// <summary>
/// Calculate the efficient frontier for a given covariance matrix and mean vector
/// </summary>
/// <param name="covariance">Covariance Matrix of assets included in portfolio</param>
/// <param name="mean">Expected return of assets in portfolio</param>
public IEnumerable <IPortfolio> Calculate(int digits = 4)
{
// MVO using quadratic programming
// Optimal portfolio is:
// min(-dvec'bvec+1/2x'Dmat*x) - where ' is the transpose of vector/matrix
// Dmat - Covariance Matrix - quadratic terms
// dvec - [0..nAssets] - linear terms
// Amat - variable weigths in constraints equation
// bvec - constraint equalities
// with constraints
// A'x >= b
// meq = eqsumW
var meanReturns = from sp in _samplePortfolio
select sp.Mean;
var cov = from ins in _samplePortfolio
select new KeyValuePair <string, Dictionary <string, double> >(ins.ID, ins.Covariance);
var covariance = CovarianceMatrix.Create(cov.ToDictionary(a => a.Key, b => b.Value));
List <IPortfolio> portfolios = new List <IPortfolio>();
// generate sequence of target returns for the efficient frontier and minimum variance locus
var targetReturns = new double[_numPortfolios].Seq(meanReturns.Min(), meanReturns.Max(), (int)_numPortfolios, digits);
double[] dvec = new double[_samplePortfolio.Count].Zeros(_samplePortfolio.Count);
// For every target return find the minimum variance portfolio
for (int i = 0; i < _numPortfolios; i++)
{
var portfConf = new ConfigurationManager(_samplePortfolio, targetReturns[i]);
OptimizationResult result;
try
{
result = QuadProg.Solve(covariance, dvec, portfConf.Amat, portfConf.Bvec, portfConf.NumEquals);
}
catch (Exception e)
{
// Solution not found - create NaN Portfolio
result = new OptimizationResult(new double[] { double.NaN }, double.NaN);
// Log error
Console.WriteLine(e.Message);
}
var portf = PortfolioFactory.Create(_samplePortfolio, i.ToString(), targetReturns[i], result.Value);
for (int c = 0; c < result.Solution.Length; c++)
{
portf[_samplePortfolio[c].ID].Weight = result.Solution[c];
}
portfolios.Add(portf);
}
return(portfolios);
}
public void StartEngine()
{
// Load data
cov = CovarianceMatrix.Create("D:/repos/windows/portfolio_optimization/datasetcov.csv");
var norm = new Normal(0.008, 0.02);
norm.RandomSource = new Random(11);
var data = norm.Samples();
var iter = data.GetEnumerator();
var meankv = from k in cov.Keys
let d = iter.MoveNext()
select new KeyValuePair <string, double>(k, Math.Round(iter.Current, 4));
mean = meankv.ToDictionary(a => a.Key, b => b.Value);
}
public static Dictionary <string, double> MarginalRisk(IPortfolio portfolio)
{
// Marginal contribution to risk --> d/dw (sigma) = (cov*w)/sigma
var marr = from ins in portfolio
select new Tuple <string, Dictionary <string, double> >(ins.ID, ins.Covariance);
var cov = CovarianceMatrix.Create(marr.ToDictionary(x => x.Item1, y => y.Item2));
var weights = new DenseVector((from ins in portfolio
select ins.Weight).ToArray());
var sigma = Math.Sqrt(weights.ToRowMatrix().Multiply(cov).Multiply(weights).First());
var mcr = cov.Multiply(weights).Divide(sigma);
return(null);
}
private double[][] GetSamples(int howMany, List <BooleanStatistic> statistics)
{
var disitrubtion = new NormalDistribution(0, Math.Sqrt(1));
var mean = new double[CovarianceMatrix.GetLength(0)];
for (int i = 0; i < CovarianceMatrix.GetLength(0); i++)
{
mean[i] = disitrubtion.InverseDistributionFunction(GetMean(i, statistics));
}
var mnormaldist = new MultivariateNormalDistribution(mean, CovarianceMatrix);
var samples = mnormaldist.Generate(howMany);
samples = Booleanize(samples);
return(samples);
}
static void Main(string[] args)
{
Dictionary <string, double> mean;
CovarianceMatrix cov;
// Load data
cov = CovarianceMatrix.Create("D:/repos/windows/portfolio_optimization/datasetcov.csv");
var norm = new Normal(0.008, 0.02);
norm.RandomSource = new Random(11);
var data = norm.Samples();
var iter = data.GetEnumerator();
var meankv = from k in cov.Keys
let d = iter.MoveNext()
select new KeyValuePair <string, double>(k, Math.Round(iter.Current, 4));
mean = meankv.ToDictionary(a => a.Key, b => b.Value);
//PortfolioOptimizer.Initialize();
// Create new portfolio
var portf = new Portfolio("TestPortfolio");
// Create instruments from data
var instruments = from k in cov.Keys
select new Instrument(k, mean[k], cov[k]);
portf.AddRange(instruments);
// Add portfolio constraints
portf.AddAllInvestedConstraint();
portf.AddLongOnlyConstraint();
double rf = 0.05;
int runs = 100;
for (int c = 0; c < runs; c++)
{
var res = PortfolioOptimizer.CalcEfficientFrontier(portf, rf, 50);
Console.WriteLine(c);
}
}
private void Calc()
{
CM = new CovarianceMatrix(ref ID);
FF = new FormingFilter(ref ID);
KF = new KalmanFilter(ref ID, ref FF);
}
