public static NArray CorrelationMatrixToWeights(NArray correlationMatrix)
        {
            var nearestCorrelationMatrix = NearestCorrelationMatrix(correlationMatrix);
            var cholesky = NMath.CholeskyDecomposition(nearestCorrelationMatrix);

            // the weights are simply the Cholesky decomposition
            return(cholesky);
        }
Пример #2
0
        private NArray CalculateSyntheticReturns(NArray correlationMatrix, int returnsCount)
        {
            var location = StorageLocation.Host;
            var cholesky = NMath.CholeskyDecomposition(correlationMatrix);
            var variates = new NArray(location, returnsCount, correlationMatrix.RowCount);

            using (var stream = new RandomNumberStream(location))
            {
                var normal = new Normal(stream, 0, 1);
                variates.FillRandom(normal);
            }
            return(variates * cholesky.Transpose());
        }
        public static void AddMultivariateModelWeightsProvider(Context context,
                                                               IList <string> identifiers, NArray correlationMatrix)
        {
            correlationMatrix = CorrelationHelper.NearestCorrelationMatrix(correlationMatrix);

            var weightsCount  = correlationMatrix.RowCount;
            var weightsMatrix = NMath.CholeskyDecomposition(correlationMatrix).Transpose();

            var weights = context.Data.AddCalibrationParametersProvider
                              (new WeightsProvider(weightsCount));

            for (int i = 0; i < weightsMatrix.ColumnCount; ++i)
            {
                weights.AddValue(identifiers[i], weightsMatrix.Column(i));
            }
        }
Пример #4
0
        private List <string> CreateTestWeightsProvider(Context context,
                                                        WeightsType weightsType, int returnsCount = 1000)
        {
            var correlationMatrix = context.Factory.CreateNArray(new double[, ] {
                { 1.0, 0.84, -0.42 },
                { 0.84, 1.0, 0.14 },
                { -0.42, 0.14, 1.0 }
            });

            correlationMatrix = CorrelationHelper.NearestCorrelationMatrix(correlationMatrix);

            int    weightsCount;
            NArray weightsMatrix;

            if (weightsType == WeightsType.Returns)
            {
                weightsCount  = returnsCount;
                weightsMatrix = CalculateSyntheticReturns(correlationMatrix, weightsCount);
            }
            else
            {
                weightsCount  = correlationMatrix.RowCount;
                weightsMatrix = NMath.CholeskyDecomposition(correlationMatrix);
            }

            var weights = context.Data.AddCalibrationParametersProvider
                              (new WeightsProvider(weightsCount));

            var identifiers = Enumerable.Range(1, weightsMatrix.ColumnCount)
                              .Select(i => string.Format("TestFactor{0}", i)).ToList();

            for (int i = 0; i < weightsMatrix.ColumnCount; ++i)
            {
                weights.AddValue(identifiers[i], weightsMatrix.Column(i));
            }

            return(identifiers);
        }