public static Portfolio CalculateLinear(double[,] equity, double reliability, double maximumLoss, double minimumCoefficientValue) { CalculateLinearValidation(reliability, maximumLoss); double[,] deltaEquity = NumericalMethods.CalculateAbsoluteVariation(equity); double[,] sigma = Statistics.CalculateCovarianceMatrix(deltaEquity); double factor = NumericalMethods.Sqrt(sigma.Maximum()); if (factor <= 0) { string st = string.Format("Runtime error: invalid factor = {0}", factor); throw new InvalidOperationException(st); } NumericalMethods.Multiply(deltaEquity, 1 / factor); double[] profit = Statistics.CalculateAverage(deltaEquity); sigma = Statistics.CalculateCovarianceMatrix(deltaEquity); MathArgs args = new MathArgs(); args.Add("$profit", profit); args.Add("$reliability", reliability); args.Add("$covariance", sigma); args.Add("$loss", maximumLoss / factor); args.Add("$coefficient", minimumCoefficientValue); Dictionary <string, object> output = MathematicaKernel.Execute(s_portfolioDiscrete, args); Portfolio result = new Portfolio(); result.Profit = (double)output["profit"] * factor; result.When = (double)output["when"]; result.Coefficients = (double[])output["result"]; return(result); }
/// <summary> /// The method looks for a stability region. /// threshold value = limitValue + sigmaCoefficient * sigma; /// </summary> /// <param name="data">can't be null</param> /// <param name="limitValue"></param> /// <param name="sigmaCoefficient">defines filter amplitude and direction; see threshold value calculation</param> /// <returns> /// true cells defines stability region /// false cells defines instability region /// </returns> public static bool[,] FindStabilityRegion(double[,] data, double sigmaFactor, BinaryFunction predicate, double limitValue = 1) { int rows = data.GetLength(0); int columns = data.GetLength(1); List <double> deviations = new List <double>(); for (int row = 0; row < rows; ++row) { for (int column = 0; column < columns; ++column) { double value = data[row, column]; if (row - 1 >= 0) { double delta = data[row - 1, column] - value; deviations.Add(delta); } if (row < rows - 1) { double delta = data[row + 1, column] - value; deviations.Add(delta); } if (column - 1 >= 0) { double delta = data[row, column - 1] - value; deviations.Add(delta); } if (column < columns - 1) { double delta = data[row, column + 1] - value; deviations.Add(delta); } } } double sigma = Statistics.CalculateSampleVariance(deviations.ToArray()); sigma = NumericalMethods.Sqrt(sigma); sigma *= sigmaFactor; double threshold = predicate(1, 0) ? (limitValue - sigma) : (limitValue + sigma); bool[,] result = new bool[rows, columns]; for (int row = 0; row < rows; ++row) { for (int column = 0; column < columns; ++column) { result[row, column] = predicate(data[row, column], threshold); } } double ry = NumericalMethods.Sqrt(rows); double rx = NumericalMethods.Sqrt(columns); int r = (int)Math.Min(rx, ry) - 1; for (int index = 0; index < r; ++index) { result = Morphology.Erosion(result); } return(result); }
public static bool[,] Erosion(bool[,] data, int row, int column) { int rows = data.GetLength(0); int columns = data.GetLength(1); double ry = NumericalMethods.Sqrt(rows); double rx = NumericalMethods.Sqrt(columns); int radius = (int)Math.Min(rx, ry); bool[,] result = Erosion(data, row, column, radius); return(result); }
private static bool CalculateLinearFastInternal(Portfolio portfolio, bool[] zeros, double[,] sigma, double[] profit, double[] margin, double reliability, double maximumLoss, double minimumCoefficientValue, double marginThreshold) { int count = 0; Dictionary <int, int> map = new Dictionary <int, int>(); for (int index = 0; index < zeros.Length; ++index) { bool status = zeros[index]; if (!status) { map[map.Count] = index; ++count; } } if (0 == count) { return(true); // nothing to do } // create sub-matrix double[,] _sigma = new double[count, count]; double[] _profit = new double[count]; double[] _margin = new double[count]; for (int row = 0; row < _profit.Length; ++row) { int r = map[row]; _profit[row] = profit[r]; _margin[row] = margin[r]; for (int column = 0; column < _profit.Length; ++column) { int c = map[column]; _sigma[row, column] = sigma[r, c]; } } // calculate factor and check it double factor = NumericalMethods.Sqrt(_sigma.Maximum()); if (factor <= 0) { string st = string.Format("Runtime error: invalid factor = {0}", factor); throw new InvalidOperationException(st); } // normalize data NumericalMethods.Multiply(_sigma, 1 / factor / factor); NumericalMethods.Multiply(_profit, 1 / factor); NumericalMethods.Multiply(_margin, 1 / factor); MathArgs args = new MathArgs(); args.Add("$profit", _profit); args.Add("$reliability", reliability); args.Add("$covariance", _sigma); args.Add("$loss", maximumLoss / factor); args.Add("$threshold", marginThreshold / factor); args.Add("$margin", _margin); Dictionary <string, object> output = MathematicaKernel.Execute(s_portfolioMargin, args); double[] coefficients = (double[])output["result"]; // check results bool result = FastPositiveMinimalThreshold(zeros, minimumCoefficientValue, count, map, coefficients); if (!result) { return(result); } // prepare results for (int index = 0; index < count; ++index) { portfolio.Coefficients[map[index]] = coefficients[index]; } portfolio.Profit = (double)output["profit"] * factor; portfolio.When = (double)output["when"]; return(result); }