/**
* Computes the structure and the expected return of the tangency portfolio;
*/
void EfficientPortfolioWithRisklessAsset::_computeTangencyPortfolio()
{
Eigen::LDLT<Eigen::MatrixXd> ldlt;
ldlt.compute(variance);
Eigen::VectorXd one = Eigen::VectorXd::Constant(dim - 1, 1.0);
Eigen::VectorXd excessReturn = mean - _risklessRate * one;
_inverseTimesExcessReturn = ldlt.solve(excessReturn);
_tangencyPortfolio = Eigen::VectorXd::Constant(dim, 0.0);
_tangencyPortfolio.head(dim - 1) = 1.0 / (alpha - gamma * _risklessRate) * _inverseTimesExcessReturn;
_tangencyPortfolioReturn = portfolioReturn(_tangencyPortfolio);
}
void LinearRegression::Learn(const std::vector<double>& input, const std::vector<double>& output, int dataSize)
{
Reset();
mInputDim = input.size() / dataSize;
mOutputDim = output.size() / dataSize;
Eigen::MatrixXd matA(dataSize, mInputDim + 1);
Eigen::MatrixXd matB(dataSize, mOutputDim);
for (int dataId = 0; dataId < dataSize; dataId++)
{
int inputBase = dataId * mInputDim;
for (int dimId = 0; dimId < mInputDim; dimId++)
{
matA(dataId, dimId) = input.at(inputBase + dimId);
}
matA(dataId, mInputDim) = 1.0;
int outputBase = dataId * mOutputDim;
for (int dimId = 0; dimId < mOutputDim; dimId++)
{
matB(dataId, dimId) = output.at(outputBase + dimId);
}
}
Eigen::MatrixXd matAT = matA.transpose();
Eigen::MatrixXd matCoefA = matAT * matA;
Eigen::MatrixXd matCoefB = matAT * matB;
Eigen::LDLT<Eigen::MatrixXd> solver;
solver.compute(matCoefA);
Eigen::MatrixXd matRes = solver.solve(matCoefB);
//copy result
mRegMat.resize((mInputDim + 1) * mOutputDim);
for (int colId = 0; colId < mOutputDim; colId++)
{
int baseIndex = colId * (mInputDim + 1);
for (int rowId = 0; rowId <= mInputDim; rowId++)
{
mRegMat.at(baseIndex + rowId) = matRes(rowId, colId);
}
}
}
void ctms_decompositions()
{
const int maxSize = 16;
const int size = 12;
typedef Eigen::Matrix<Scalar,
Eigen::Dynamic, Eigen::Dynamic,
0,
maxSize, maxSize> Matrix;
typedef Eigen::Matrix<Scalar,
Eigen::Dynamic, 1,
0,
maxSize, 1> Vector;
typedef Eigen::Matrix<std::complex<Scalar>,
Eigen::Dynamic, Eigen::Dynamic,
0,
maxSize, maxSize> ComplexMatrix;
const Matrix A(Matrix::Random(size, size)), B(Matrix::Random(size, size));
Matrix X(size,size);
const ComplexMatrix complexA(ComplexMatrix::Random(size, size));
const Matrix saA = A.adjoint() * A;
const Vector b(Vector::Random(size));
Vector x(size);
// Cholesky module
Eigen::LLT<Matrix> LLT; LLT.compute(A);
X = LLT.solve(B);
x = LLT.solve(b);
Eigen::LDLT<Matrix> LDLT; LDLT.compute(A);
X = LDLT.solve(B);
x = LDLT.solve(b);
// Eigenvalues module
Eigen::HessenbergDecomposition<ComplexMatrix> hessDecomp; hessDecomp.compute(complexA);
Eigen::ComplexSchur<ComplexMatrix> cSchur(size); cSchur.compute(complexA);
Eigen::ComplexEigenSolver<ComplexMatrix> cEigSolver; cEigSolver.compute(complexA);
Eigen::EigenSolver<Matrix> eigSolver; eigSolver.compute(A);
Eigen::SelfAdjointEigenSolver<Matrix> saEigSolver(size); saEigSolver.compute(saA);
Eigen::Tridiagonalization<Matrix> tridiag; tridiag.compute(saA);
// LU module
Eigen::PartialPivLU<Matrix> ppLU; ppLU.compute(A);
X = ppLU.solve(B);
x = ppLU.solve(b);
Eigen::FullPivLU<Matrix> fpLU; fpLU.compute(A);
X = fpLU.solve(B);
x = fpLU.solve(b);
// QR module
Eigen::HouseholderQR<Matrix> hQR; hQR.compute(A);
X = hQR.solve(B);
x = hQR.solve(b);
Eigen::ColPivHouseholderQR<Matrix> cpQR; cpQR.compute(A);
X = cpQR.solve(B);
x = cpQR.solve(b);
Eigen::FullPivHouseholderQR<Matrix> fpQR; fpQR.compute(A);
// FIXME X = fpQR.solve(B);
x = fpQR.solve(b);
// SVD module
Eigen::JacobiSVD<Matrix> jSVD; jSVD.compute(A, ComputeFullU | ComputeFullV);
}