private PathTSPTour(PathTSPTour original, Cloner cloner) : base(original, cloner) { this.coordinates = cloner.Clone(original.coordinates); this.permutation = cloner.Clone(original.permutation); this.quality = cloner.Clone(original.quality); Initialize(); }
public static void MyClassInitialize(TestContext testContext) { random = new MersenneTwister(); symmetricDistances = new DoubleMatrix(ProblemSize, ProblemSize); symmetricWeights = new DoubleMatrix(ProblemSize, ProblemSize); asymmetricDistances = new DoubleMatrix(ProblemSize, ProblemSize); asymmetricWeights = new DoubleMatrix(ProblemSize, ProblemSize); nonZeroDiagonalDistances = new DoubleMatrix(ProblemSize, ProblemSize); nonZeroDiagonalWeights = new DoubleMatrix(ProblemSize, ProblemSize); for (int i = 0; i < ProblemSize - 1; i++) { for (int j = i + 1; j < ProblemSize; j++) { symmetricDistances[i, j] = random.Next(ProblemSize * 100); symmetricDistances[j, i] = symmetricDistances[i, j]; symmetricWeights[i, j] = random.Next(ProblemSize * 100); symmetricWeights[j, i] = symmetricWeights[i, j]; asymmetricDistances[i, j] = random.Next(ProblemSize * 100); asymmetricDistances[j, i] = random.Next(ProblemSize * 100); asymmetricWeights[i, j] = random.Next(ProblemSize * 100); asymmetricWeights[j, i] = random.Next(ProblemSize * 100); nonZeroDiagonalDistances[i, j] = random.Next(ProblemSize * 100); nonZeroDiagonalDistances[j, i] = random.Next(ProblemSize * 100); nonZeroDiagonalWeights[i, j] = random.Next(ProblemSize * 100); nonZeroDiagonalWeights[j, i] = random.Next(ProblemSize * 100); } nonZeroDiagonalDistances[i, i] = random.Next(ProblemSize * 100); nonZeroDiagonalWeights[i, i] = random.Next(ProblemSize * 100); } int index = random.Next(ProblemSize); if (nonZeroDiagonalDistances[index, index] == 0) nonZeroDiagonalDistances[index, index] = random.Next(1, ProblemSize * 100); index = random.Next(ProblemSize); if (nonZeroDiagonalWeights[index, index] == 0) nonZeroDiagonalWeights[index, index] = random.Next(1, ProblemSize * 100); assignment = new Permutation(PermutationTypes.Absolute, ProblemSize, random); }
public void Current() { DoubleMatrix test = new DoubleMatrix(new double[2, 2] { { 1, 2 }, { 3, 4 } }); IEnumerator enumerator = test.GetEnumerator(); bool movenextresult; movenextresult = enumerator.MoveNext(); Assert.IsTrue(movenextresult); Assert.AreEqual(enumerator.Current, test[0, 0]); movenextresult = enumerator.MoveNext(); Assert.IsTrue(movenextresult); Assert.AreEqual(enumerator.Current, test[1, 0]); movenextresult = enumerator.MoveNext(); Assert.IsTrue(movenextresult); Assert.AreEqual(enumerator.Current, test[0, 1]); movenextresult = enumerator.MoveNext(); Assert.IsTrue(movenextresult); Assert.AreEqual(enumerator.Current, test[1, 1]); movenextresult = enumerator.MoveNext(); Assert.IsFalse(movenextresult); }
/***********************/ /* PUBLIC CONSTRUCTORS */ /***********************/ /// <summary>Instantiates a new 2d point with the specified x and y /// coordinates. Creates a new underlying matrix data source</summary> /// <param name="x">x-coordinate of this 2d point</param> /// <param name="y">y-coordinate of this 2d point</param> public Point2D(Double x, Double y) { _matrix = new DoubleMatrix(1, 3); _matrix[0, 0] = x; _matrix[0, 1] = y; _matrix[0, 2] = 1F; }
public static DoubleMatrix ShiftToPositives(ref DoubleMatrix io_Coordinates,params DoubleMatrix[] io_AffectedAlso) { DoubleMatrix retMinMax = MinMaxByRow(io_Coordinates); DoubleMatrix growByMatrix = new DoubleMatrix(retMinMax.RowsCount, 1); growByMatrix.Init(0); Func<int, int, double, double> prepareGrowingCell = (row, col, value) => { if (retMinMax[row, sr_MinCol] < 0) { retMinMax[row, sr_MinCol] = Math.Abs(retMinMax[row, sr_MinCol]); retMinMax[row, sr_MaxCol] += retMinMax[row, sr_MinCol]; return retMinMax[row, sr_MinCol]; } else { retMinMax[row, sr_MinCol] = value; return value; } }; growByMatrix.Iterate(prepareGrowingCell); AddScalarsByDims(ref io_Coordinates, growByMatrix); for (int i = 0; i < io_AffectedAlso.Length; ++i) { AddScalarsByDims(ref io_AffectedAlso[i], growByMatrix); } return retMinMax; }
/// <summary> /// Performs a breeder genetic algorithm manipulation on the given <paramref name="vector"/>. /// </summary> /// <param name="random">A random number generator.</param> /// <param name="vector">The real vector to manipulate.</param> /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param> /// <param name="searchIntervalFactor">The factor determining the size of the search interval.</param> public static void Apply(IRandom random, RealVector vector, DoubleMatrix bounds, DoubleValue searchIntervalFactor) { int length = vector.Length; double prob, value; do { value = Sigma(random); } while (value == 0); prob = 1.0 / (double)length; bool wasMutated = false; for (int i = 0; i < length; i++) { if (random.NextDouble() < prob) { double range = bounds[i % bounds.Rows, 1] - bounds[i % bounds.Rows, 0]; if (random.NextDouble() < 0.5) { vector[i] = vector[i] + value * searchIntervalFactor.Value * range; } else { vector[i] = vector[i] - value * searchIntervalFactor.Value * range; } wasMutated = true; } } // make sure at least one gene was mutated if (!wasMutated) { int pos = random.Next(length); double range = bounds[pos % bounds.Rows, 1] - bounds[pos % bounds.Rows, 0]; if (random.NextDouble() < 0.5) { vector[pos] = vector[pos] + value * searchIntervalFactor.Value * range; } else { vector[pos] = vector[pos] - value * searchIntervalFactor.Value * range; } } }
public static double EvaluateByCoordinates(Permutation permutation, TranslocationMove move, DoubleMatrix coordinates, TSPTranslocationMovePathEvaluator evaluator) { if (move.Index1 == move.Index3 || move.Index2 == permutation.Length - 1 && move.Index3 == 0 || move.Index1 == 0 && move.Index3 == permutation.Length - 1 - move.Index2) return 0; int edge1source = permutation.GetCircular(move.Index1 - 1); int edge1target = permutation[move.Index1]; int edge2source = permutation[move.Index2]; int edge2target = permutation.GetCircular(move.Index2 + 1); int edge3source, edge3target; if (move.Index3 > move.Index1) { edge3source = permutation.GetCircular(move.Index3 + move.Index2 - move.Index1); edge3target = permutation.GetCircular(move.Index3 + move.Index2 - move.Index1 + 1); } else { edge3source = permutation.GetCircular(move.Index3 - 1); edge3target = permutation[move.Index3]; } double moveQuality = 0; // remove three edges moveQuality -= evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1], coordinates[edge1target, 0], coordinates[edge1target, 1]); moveQuality -= evaluator.CalculateDistance(coordinates[edge2source, 0], coordinates[edge2source, 1], coordinates[edge2target, 0], coordinates[edge2target, 1]); moveQuality -= evaluator.CalculateDistance(coordinates[edge3source, 0], coordinates[edge3source, 1], coordinates[edge3target, 0], coordinates[edge3target, 1]); // add three edges moveQuality += evaluator.CalculateDistance(coordinates[edge3source, 0], coordinates[edge3source, 1], coordinates[edge1target, 0], coordinates[edge1target, 1]); moveQuality += evaluator.CalculateDistance(coordinates[edge2source, 0], coordinates[edge2source, 1], coordinates[edge3target, 0], coordinates[edge3target, 1]); moveQuality += evaluator.CalculateDistance(coordinates[edge1source, 0], coordinates[edge1source, 1], coordinates[edge2target, 0], coordinates[edge2target, 1]); return moveQuality; }
public static double Apply(Permutation assignment, TranslocationMove move, DoubleMatrix weights, DoubleMatrix distances) { double moveQuality = 0; int min = Math.Min(move.Index1, move.Index3); int max = Math.Max(move.Index2, move.Index3 + (move.Index2 - move.Index1)); int iOffset, changeOffset; if (move.Index1 < move.Index3) { iOffset = move.Index2 - move.Index1 + 1; changeOffset = min + max - move.Index2; } else { iOffset = move.Index1 - move.Index3; changeOffset = min + move.Index2 - move.Index1 + 1; } for (int i = min; i <= max; i++) { if (i == changeOffset) iOffset -= (max - min + 1); int jOffset = ((move.Index1 < move.Index3) ? (move.Index2 - move.Index1 + 1) : (move.Index1 - move.Index3)); for (int j = 0; j < assignment.Length; j++) { moveQuality -= weights[i, j] * distances[assignment[i], assignment[j]]; if (j < min || j > max) { moveQuality -= weights[j, i] * distances[assignment[j], assignment[i]]; moveQuality += weights[i, j] * distances[assignment[i + iOffset], assignment[j]]; moveQuality += weights[j, i] * distances[assignment[j], assignment[i + iOffset]]; } else { if (j == changeOffset) jOffset -= (max - min + 1); moveQuality += weights[i, j] * distances[assignment[i + iOffset], assignment[j + jOffset]]; } } } return moveQuality; }
public static DoubleMatrix GetChannel(this MatrixBase<YCbCrColor> matrix, ChannelType channelType) { var ret = new DoubleMatrix(matrix.RowCount, matrix.ColumnCount); for (int i = 0; i < matrix.RowCount; i++) { for (int j = 0; j < matrix.ColumnCount; j++) { switch (channelType) { case ChannelType.Y: ret[i, j] = matrix[i, j].Y; break; case ChannelType.Cr: ret[i, j] = matrix[i, j].Cr; break; case ChannelType.Cb: ret[i, j] = matrix[i, j].Cb; break; default: throw new ArgumentOutOfRangeException("channelType"); } } } return ret; }
/// <summary> /// Checks if all elements of the given <paramref name="vector"/> are inside the bounds and if not, elements are set to the respective values of the bounds. /// </summary> /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param> /// <param name="vector">The vector to check.</param> /// <returns>The corrected real vector.</returns> public static void Apply(RealVector vector, DoubleMatrix bounds) { for (int i = 0; i < vector.Length; i++) { double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1]; if (vector[i] < min) vector[i] = min; if (vector[i] > max) vector[i] = max; } }
/// <summary> /// Performs the Kruskal-Shepard algorithm and applies a gradient descent method /// to fit the coordinates such that the difference between the fit distances /// and the dissimilarities is minimal. /// </summary> /// <remarks> /// It will use a pre-initialized x,y-coordinates matrix as a starting point of the gradient descent. /// </remarks> /// <param name="dissimilarities">A symmetric NxN matrix that specifies the dissimilarities between each element i and j. Diagonal elements are ignored.</param> /// <param name="coordinates">The Nx2 matrix of initial coordinates.</param> /// <param name="maximumIterations">The number of iterations for which the algorithm should run. /// In every iteration it tries to find the best location for every item.</param> /// <returns>A Nx2 matrix where the first column represents the x- and the second column the y coordinates.</returns> public static DoubleMatrix KruskalShepard(DoubleMatrix dissimilarities, DoubleMatrix coordinates, int maximumIterations = 10) { int dimension = dissimilarities.Rows; if (dimension != dissimilarities.Columns || coordinates.Rows != dimension) throw new ArgumentException("The number of coordinates and the number of rows and columns in the dissimilarities matrix do not match."); double epsg = 1e-7; double epsf = 0; double epsx = 0; int maxits = 0; alglib.minlmstate state; alglib.minlmreport rep; for (int iterations = 0; iterations < maximumIterations; iterations++) { bool changed = false; for (int i = 0; i < dimension; i++) { double[] c = new double[] { coordinates[i, 0], coordinates[i, 1] }; try { alglib.minlmcreatevj(dimension - 1, c, out state); alglib.minlmsetcond(state, epsg, epsf, epsx, maxits); alglib.minlmoptimize(state, StressFitness, StressJacobian, null, new Info(coordinates, dissimilarities, i)); alglib.minlmresults(state, out c, out rep); } catch (alglib.alglibexception) { } if (!double.IsNaN(c[0]) && !double.IsNaN(c[1])) { changed = changed || (coordinates[i, 0] != c[0]) || (coordinates[i, 1] != c[1]); coordinates[i, 0] = c[0]; coordinates[i, 1] = c[1]; } } if (!changed) break; } return coordinates; }
static DoubleQRDecompTest() { DoubleMatrix a = new DoubleMatrix(3); a[0,0] = -1.0; a[0,1] = 5.0; a[0,2] = 6.0; a[1,0] = 3.0; a[1,1] = -6.0; a[1,2] = 1.0; a[2,0] = 6.0; a[2,1] = 8.0; a[2,2] = 9.0; qr = new DoubleQRDecomp(a); a = new DoubleMatrix(2,3); a[0,0] = -1.0; a[0,1] = 5.0; a[0,2] = 6.0; a[1,0] = 3.0; a[1,1] = -6.0; a[1,2] = 1.0; wqr = new DoubleQRDecomp(a); a = new DoubleMatrix(3,2); a[0,0] = -1.0; a[0,1] = 5.0; a[1,0] = 3.0; a[1,1] = -6.0; a[2,0] = 6.0; a[2,1] = 8.0; lqr = new DoubleQRDecomp(a); }
public static double CalculatePhenotypeDistance(Permutation a, Permutation b, DoubleMatrix weights, DoubleMatrix distances) { Dictionary<double, Dictionary<double, int>> alleles = new Dictionary<double, Dictionary<double, int>>(); int distance = 0, len = a.Length; for (int x = 0; x < len; x++) { for (int y = 0; y < len; y++) { // there's a limited universe of double values as they're all drawn from the same matrix double dA = distances[a[x], a[y]], dB = distances[b[x], b[y]]; if (dA == dB) continue; Dictionary<double, int> dAlleles; if (!alleles.ContainsKey(weights[x, y])) { dAlleles = new Dictionary<double, int>(); alleles.Add(weights[x, y], dAlleles); } else dAlleles = alleles[weights[x, y]]; int countA = 1, countB = -1; if (dAlleles.ContainsKey(dA)) countA += dAlleles[dA]; if (dAlleles.ContainsKey(dB)) countB += dAlleles[dB]; if (countA <= 0) distance--; // we've found in A an allele that was present in B else distance++; // we've found in A a new allele dAlleles[dA] = countA; if (countB >= 0) distance--; // we've found in B an allele that was present in A else distance++; // we've found in B a new allele dAlleles[dB] = countB; } } return distance / (double)(2 * len * len); }
public void MichalewiczNonUniformAllPositionsManipulatorApplyTest() { TestRandom random = new TestRandom(); RealVector parent, expected; DoubleValue generationsDependency; DoubleMatrix bounds; IntValue currentGeneration, maximumGenerations; bool exceptionFired; // The following test is not based on published examples random.Reset(); random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 }; parent = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 }); expected = new RealVector(new double[] { 0.45, 0.22, 0.3, 0.6, 0.14 }); bounds = new DoubleMatrix(new double[,] { { 0.3, 0.7 } }); generationsDependency = new DoubleValue(0.1); currentGeneration = new IntValue(1); maximumGenerations = new IntValue(4); MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, bounds, currentGeneration, maximumGenerations, generationsDependency); Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent)); // The following test is not based on published examples exceptionFired = false; random.Reset(); random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 }; parent = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 }); bounds = new DoubleMatrix(new double[,] { { 0.3, 0.7 } }); generationsDependency = new DoubleValue(0.1); currentGeneration = new IntValue(5); //current generation > max generation maximumGenerations = new IntValue(4); try { MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, bounds, currentGeneration, maximumGenerations, generationsDependency); } catch (System.ArgumentException) { exceptionFired = true; } Assert.IsTrue(exceptionFired); }
private DoubleArray Randomize(IRandom random, int length, DoubleMatrix bounds) { var result = new DoubleArray(length); for (int i = 0; i < length; i++) { result[i] = random.NextDouble() * bounds[i % bounds.Rows, 1] - bounds[i % bounds.Rows, 0]; } return result; }
public void Calculate(DoubleMatrix i_TargetMapping) { if (m_SourceMapping != null) { m_PixelMapping = pixelMapping(m_SourceMapping, i_TargetMapping, m_MeshSize); } }
internal static ArrayList run(IList para) { modshogun.init_shogun_with_defaults(); int degree = (int)((int?)para[0]); string[] fm_train_dna = Load.load_dna("../data/fm_train_dna.dat"); string[] fm_test_dna = Load.load_dna("../data/fm_test_dna.dat"); StringCharFeatures feats_train = new StringCharFeatures(fm_train_dna, DNA); StringCharFeatures feats_test = new StringCharFeatures(fm_test_dna, DNA); WeightedDegreeStringKernel kernel = new WeightedDegreeStringKernel(feats_train, feats_train, degree); double[] w = new double[degree]; double sum = degree * (degree + 1)/2; for (int i = 0; i < degree; i++) { w[i] = (degree - i)/sum; } DoubleMatrix weights = new DoubleMatrix(1, degree, w); kernel.set_wd_weights(weights); DoubleMatrix km_train = kernel.get_kernel_matrix(); kernel.init(feats_train, feats_test); DoubleMatrix km_test = kernel.get_kernel_matrix(); ArrayList result = new ArrayList(); result.Add(km_train); result.Add(km_test); result.Add(kernel); modshogun.exit_shogun(); return result; }
/// <summary> /// Calculates the quality of the move <paramref name="move"/> by evaluating the changes. /// The runtime complexity of this method is O(N) with N being the size of the permutation. /// </summary> /// <param name="assignment">The current permutation.</param> /// <param name="move">The move that is to be evaluated if it was applied to the current permutation.</param> /// <param name="weights">The weights matrix.</param> /// <param name="distances">The distances matrix.</param> /// <returns>The relative change in quality if <paramref name="move"/> was applied to <paramref name="assignment"/>.</returns> public static double Apply(Permutation assignment, ScrambleMove move, DoubleMatrix weights, DoubleMatrix distances) { double moveQuality = 0; int min = move.StartIndex; int max = min + move.ScrambledIndices.Length - 1; for (int i = min; i <= max; i++) { int locI = assignment[i]; int newlocI = assignment[min + move.ScrambledIndices[i - min]]; if (locI == newlocI) continue; for (int j = 0; j < assignment.Length; j++) { int locJ = assignment[j]; if (j >= min && j <= max) { int newlocJ = assignment[min + move.ScrambledIndices[j - min]]; moveQuality += weights[i, j] * (distances[newlocI, newlocJ] - distances[locI, locJ]); if (locJ == newlocJ) moveQuality += weights[j, i] * (distances[newlocJ, newlocI] - distances[locJ, locI]); } else { moveQuality += weights[i, j] * (distances[newlocI, locJ] - distances[locI, locJ]); moveQuality += weights[j, i] * (distances[locJ, newlocI] - distances[locJ, locI]); } } } return moveQuality; }
private QAPAssignment(QAPAssignment original, Cloner cloner) : base(original, cloner) { distances = cloner.Clone(original.distances); weights = cloner.Clone(original.weights); assignment = cloner.Clone(original.assignment); quality = cloner.Clone(original.quality); }
/// <summary>Performs the QR factorization.</summary> protected override void InternalCompute() { int m = matrix.Rows; int n = matrix.Columns; #if MANAGED int minmn = m < n ? m : n; r_ = new DoubleMatrix(matrix); // create a copy DoubleVector[] u = new DoubleVector[minmn]; for (int i = 0; i < minmn; i++) { u[i] = Householder.GenerateColumn(r_, i, m - 1, i); Householder.UA(u[i], r_, i, m - 1, i + 1, n - 1); } q_ = DoubleMatrix.CreateIdentity(m); for (int i = minmn - 1; i >= 0; i--) { Householder.UA(u[i], q_, i, m - 1, i, m - 1); } #else qr = new double[matrix.data.Length]; Array.Copy(matrix.data, qr, matrix.data.Length); jpvt = new int[n]; jpvt[0] = 1; Lapack.Geqp3.Compute(m, n, qr, m, jpvt, out tau); r_ = new DoubleMatrix(m, n); // Populate R for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (i <= j) { r_.data[j * m + i] = qr[(jpvt[j]-1) * m + i]; } else { r_.data[j * m + i] = 0.0; } } } q_ = new DoubleMatrix(m, m); for (int i = 0; i < m; i++) { for (int j = 0; j < m; j++) { if (j < n) q_.data[j * m + i] = qr[j * m + i]; else q_.data[j * m + i] = 0.0; } } if( m < n ){ Lapack.Orgqr.Compute(m, m, m, q_.data, m, tau); } else{ Lapack.Orgqr.Compute(m, m, n, q_.data, m, tau); } #endif for (int i = 0; i < m; i++) { if (q_[i, i] == 0) isFullRank = false; } }
public void Calculate(DoubleMatrix i_SourceMapping, DoubleMatrix i_TargetMapping) { if (i_TargetMapping.RowsCount >= sr_TPSminNumOfSamples) { m_SourceMapping = i_SourceMapping; m_PixelMapping = pixelMapping(m_SourceMapping, i_TargetMapping, m_MeshSize); } }
public static double Impact(int facility, Permutation assignment, DoubleMatrix weights, DoubleMatrix distances) { double impact = 0; for (int i = 0; i < assignment.Length; i++) { impact += weights[facility, i] * distances[assignment[facility], assignment[i]]; impact += weights[i, facility] * distances[assignment[i], assignment[facility]]; } return impact; }
/// <summary>Instantiates a new 2d point using the provided augmented vector /// matrix as the underlying data source</summary> /// <param name="augmentedMatrix">Augmented 3x1 matrix containing the point coordinates</param> public Point2D(DoubleMatrix augmentedMatrix) { if (augmentedMatrix == null) throw new ArgumentNullException("augmentedMatrix"); if (augmentedMatrix.RowCount != 1) throw new DimensionMismatchException(); if (augmentedMatrix.ColumnCount != 3) throw new DimensionMismatchException(); if (augmentedMatrix[0, 2] != 1) throw new ArgumentException("Point matrix does not appear to be an augmented 3x1 2-d point matrix in form [x, y, 1]", "augmentedMatrix"); _matrix = augmentedMatrix; }
/// <summary> /// Creating a matching object based on two sets of points. /// </summary> /// <param name="i_Source">2 x M1 points the first row is the X value, the second is the Y value</param> /// <param name="i_Target">2 x M2 points the first row is the X value, the second is the Y value</param> public PCAMatching(DoubleMatrix i_Source, DoubleMatrix i_Target) { if (i_Source.RowsCount != i_Target.RowsCount) { throw new PCAException("Cannot match between two sets with different dimensions"); } m_SourceTransform = new PCAtransform(i_Source); m_TargetTransform = new PCAtransform(i_Target); }
public static double Apply(Permutation assignment, DoubleMatrix weights, DoubleMatrix distances) { double quality = 0; for (int i = 0; i < assignment.Length; i++) { for (int j = 0; j < assignment.Length; j++) { quality += weights[i, j] * distances[assignment[i], assignment[j]]; } } return quality; }
public void Calculate(DoubleMatrix i_SourceMapping, DoubleMatrix i_TargetMapping, ref Point[] io_FullSet) { if (i_TargetMapping.RowsCount >= sr_TPSminNumOfSamples) { m_SourceMapping = i_SourceMapping; m_PixelMapping = pixelMapping(m_SourceMapping, i_TargetMapping, m_MeshSize); interpolate2D(m_MeshSize, m_PixelMapping, ref io_FullSet); } }
public static double Apply(TSPCoordinatesPathEvaluator evaluator, DoubleMatrix coordinates, Permutation tour) { DoubleMatrix c = coordinates; Permutation p = tour; double length = 0; for (int i = 0; i < p.Length - 1; i++) length += evaluator.CalculateDistance(c[p[i], 0], c[p[i], 1], c[p[i + 1], 0], c[p[i + 1], 1]); length += evaluator.CalculateDistance(c[p[p.Length - 1], 0], c[p[p.Length - 1], 1], c[p[0], 0], c[p[0], 1]); return length; }
protected override void Content_CorrelationCalculationFinished(object sender, FeatureCorrelationCalculator.CorrelationCalculationFinishedArgs e) { if (InvokeRequired) { Invoke(new FeatureCorrelationCalculator.CorrelationCalculationFinishedHandler(Content_CorrelationCalculationFinished), sender, e); return; } correlationCache.SetCorrelation(e.Calculcator, e.Partition, e.Correlation); var correlation = new DoubleMatrix(e.Correlation, Content.Dataset.DoubleVariables, Content.Dataset.DoubleVariables); UpdateDataView(correlation); }
/// <summary> /// returns a DoubleMatrix with the given band structure planarised in the transverse direction /// </summary> public static Band_Data Expand_BandStructure(DoubleVector structure, int ny) { DoubleMatrix result = new DoubleMatrix(ny, structure.Length); for (int i = 0; i < ny; i++) for (int j = 0; j < structure.Length; j++) result[i, j] = structure[j]; return new Band_Data(result); }
public static void SubstractScalarsByDims(ref DoubleMatrix io_leftHandMatrix, DoubleMatrix i_rightHandVector) { if ((i_rightHandVector.ColumnsCount > 1) || (io_leftHandMatrix.RowsCount != i_rightHandVector.RowsCount)) { throw new PCAException("Dimension are not meet for substraction of a vector from matrix by rows"); } Func<int, int, double, double> substractByDim = (row, col, Val) => (Val - (double)i_rightHandVector[row, 0]); io_leftHandMatrix.Iterate(substractByDim); }
public override double Calculate(int from, int to, DoubleMatrix coordinates) { return(DistanceHelper.GetDistance(DistanceMeasure.UpperEuclidean, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1])); }
public static double CalculatePhenotypeDistance(Permutation a, Permutation b, DoubleMatrix weights, DoubleMatrix distances) { Dictionary <double, Dictionary <double, int> > alleles = new Dictionary <double, Dictionary <double, int> >(); int distance = 0, len = a.Length; for (int x = 0; x < len; x++) { for (int y = 0; y < len; y++) { // there's a limited universe of double values as they're all drawn from the same matrix double dA = distances[a[x], a[y]], dB = distances[b[x], b[y]]; if (dA == dB) { continue; } Dictionary <double, int> dAlleles; if (!alleles.ContainsKey(weights[x, y])) { dAlleles = new Dictionary <double, int>(); alleles.Add(weights[x, y], dAlleles); } else { dAlleles = alleles[weights[x, y]]; } int countA = 1, countB = -1; if (dAlleles.ContainsKey(dA)) { countA += dAlleles[dA]; } if (dAlleles.ContainsKey(dB)) { countB += dAlleles[dB]; } if (countA <= 0) { distance--; // we've found in A an allele that was present in B } else { distance++; // we've found in A a new allele } dAlleles[dA] = countA; if (countB >= 0) { distance--; // we've found in B an allele that was present in A } else { distance++; // we've found in B a new allele } dAlleles[dB] = countB; } } return(distance / (double)(2 * len * len)); }
internal static DoubleArray nodeSensitivity(double xValue, DoubleArray knots, DoubleMatrix coefMatrix, int dimensions, int interval, DoubleMatrix coefficientSensitivity) { double s = xValue - knots.get(interval); int nCoefs = coefficientSensitivity.rowCount(); DoubleArray res = coefficientSensitivity.row(0); for (int i = 1; i < nCoefs; i++) { res = (DoubleArray)MA.scale(res, s); res = (DoubleArray)MA.add(res, coefficientSensitivity.row(i)); } return(res); }
static TestableSpectralDecomposition01() { double[] realArray = new double[9] { 2, 2, 0, 2, 0, 0, 0, 0, 5 }; double[] imaginaryArray = new double[9] { 0, 1, 0, -1, 0, 0, 0, 0, 0 }; var complexArray = new Complex[9]; for (int i = 0; i < 9; i++) { complexArray[i] = new Complex(realArray[i], imaginaryArray[i]); } testableMatrix = new TestableComplexMatrix( asColumnMajorDenseArray: complexArray, numberOfRows: 3, numberOfColumns: 3, isUpperHessenberg: false, isLowerHessenberg: false, isUpperTriangular: false, isLowerTriangular: false, isSymmetric: false, isSkewSymmetric: false, isHermitian: false, isSkewHermitian: false, upperBandwidth: 0, lowerBandwidth: 2); values = DoubleMatrix.Dense(3, 3); values[0, 0] = -1.449489742783178; values[1, 1] = 3.449489742783178; values[2, 2] = 5; vectorsIfLower = ComplexMatrix.Dense(3, 3, new Complex[9] { -0.543944717, new Complex(0.750532688, 0.375266344), 0, -0.839121055171381, new Complex(-0.486518945, -0.243259472), 0, 0, 0, 1 }); vectorsIfUpper = ComplexMatrix.Dense(3, 3, new Complex[9] { new Complex(0.486518945, -0.243259472), -0.839121055171381, 0, new Complex(0.750532688, -0.375266344), 0.543944717, 0, 0, 0, 1 }); }
public LAPAssignment(DoubleMatrix costs, StringArray rowNames, StringArray columnNames, Permutation assignment) : this(costs, assignment) { this.rowNames = rowNames; this.columnNames = columnNames; }
public LAPAssignment(DoubleMatrix costs, Permutation assignment) { this.costs = costs; this.assignment = assignment; }
/// <summary> /// Mutates the endogenous strategy parameters. /// </summary> /// <param name="random">The random number generator to use.</param> /// <param name="vector">The strategy vector to manipulate.</param> /// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param> /// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param> /// <param name="bounds">The minimal and maximal value for each component, bounds are cycled if the length of bounds is smaller than the length of vector</param> public static void Apply(IRandom random, DoubleArray vector, double generalLearningRate, double learningRate, DoubleMatrix bounds) { NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0); double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble()); for (int i = 0; i < vector.Length; i++) { double change = vector[i] * generalMultiplier *Math.Exp(learningRate *N.NextDouble()); if (bounds != null) { double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1]; if (min == max) { vector[i] = min; } else { if (change < min || change > max) { change = Math.Max(min, Math.Min(max, change)); } vector[i] = change; } } } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public PiecewisePolynomialResult2D interpolate(final double[] x0Values, final double[] x1Values, final double[][] yValues) public override PiecewisePolynomialResult2D interpolate(double[] x0Values, double[] x1Values, double[][] yValues) { ArgChecker.notNull(x0Values, "x0Values"); ArgChecker.notNull(x1Values, "x1Values"); ArgChecker.notNull(yValues, "yValues"); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int nData0 = x0Values.length; int nData0 = x0Values.Length; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int nData1 = x1Values.length; int nData1 = x1Values.Length; DoubleMatrix yValuesMatrix = DoubleMatrix.copyOf(yValues); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.math.impl.function.PiecewisePolynomialFunction1D func = new com.opengamma.strata.math.impl.function.PiecewisePolynomialFunction1D(); PiecewisePolynomialFunction1D func = new PiecewisePolynomialFunction1D(); //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: double[][] diff0 = new double[nData1][nData0]; double[][] diff0 = RectangularArrays.ReturnRectangularDoubleArray(nData1, nData0); //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: double[][] diff1 = new double[nData0][nData1]; double[][] diff1 = RectangularArrays.ReturnRectangularDoubleArray(nData0, nData1); //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: double[][] cross = new double[nData0][nData1]; double[][] cross = RectangularArrays.ReturnRectangularDoubleArray(nData0, nData1); PiecewisePolynomialResult result0 = _method[0].interpolate(x0Values, OG_ALGEBRA.getTranspose(yValuesMatrix).toArray()); diff0 = func.differentiate(result0, x0Values).toArray(); PiecewisePolynomialResult result1 = _method[1].interpolate(x1Values, yValuesMatrix.toArray()); diff1 = func.differentiate(result1, x1Values).toArray(); const int order = 4; for (int i = 0; i < nData0; ++i) { for (int j = 0; j < nData1; ++j) { if (yValues[i][j] == 0.0) { if (diff0[j][i] == 0.0) { cross[i][j] = diff1[i][j]; } else { if (diff1[i][j] == 0.0) { cross[i][j] = diff0[j][i]; } else { cross[i][j] = Math.Sign(diff0[j][i] * diff1[i][j]) * Math.Sqrt(Math.Abs(diff0[j][i] * diff1[i][j])); } } } else { cross[i][j] = diff0[j][i] * diff1[i][j] / yValues[i][j]; } } } //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: DoubleMatrix[][] coefMat = new DoubleMatrix[nData0 - 1][nData1 - 1]; DoubleMatrix[][] coefMat = RectangularArrays.ReturnRectangularDoubleMatrixArray(nData0 - 1, nData1 - 1); for (int i = 0; i < nData0 - 1; ++i) { for (int j = 0; j < nData1 - 1; ++j) { double[] diffsVec = new double[16]; for (int l = 0; l < 2; ++l) { for (int m = 0; m < 2; ++m) { diffsVec[l + 2 * m] = yValues[i + l][j + m]; } } for (int l = 0; l < 2; ++l) { for (int m = 0; m < 2; ++m) { diffsVec[4 + l + 2 * m] = diff0[j + m][i + l]; } } for (int l = 0; l < 2; ++l) { for (int m = 0; m < 2; ++m) { diffsVec[8 + l + 2 * m] = diff1[i + l][j + m]; } } for (int l = 0; l < 2; ++l) { for (int m = 0; m < 2; ++m) { diffsVec[12 + l + 2 * m] = cross[i + l][j + m]; } } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray diffs = com.opengamma.strata.collect.array.DoubleArray.copyOf(diffsVec); DoubleArray diffs = DoubleArray.copyOf(diffsVec); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray ansVec = ((com.opengamma.strata.collect.array.DoubleArray) OG_ALGEBRA.multiply(INV_MAT, diffs)); DoubleArray ansVec = ((DoubleArray)OG_ALGEBRA.multiply(INV_MAT, diffs)); double @ref = 0.0; //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: double[][] coefMatTmp = new double[order][order]; double[][] coefMatTmp = RectangularArrays.ReturnRectangularDoubleArray(order, order); for (int l = 0; l < order; ++l) { for (int m = 0; m < order; ++m) { coefMatTmp[order - l - 1][order - m - 1] = ansVec.get(l + m * (order)) / Math.Pow((x0Values[i + 1] - x0Values[i]), l) / Math.Pow((x1Values[j + 1] - x1Values[j]), m); ArgChecker.isFalse(double.IsNaN(coefMatTmp[order - l - 1][order - m - 1]), "Too large/small input"); ArgChecker.isFalse(double.IsInfinity(coefMatTmp[order - l - 1][order - m - 1]), "Too large/small input"); @ref += coefMatTmp[order - l - 1][order - m - 1] * Math.Pow((x0Values[i + 1] - x0Values[i]), l) * Math.Pow((x1Values[j + 1] - x1Values[j]), m); } } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double bound = Math.max(Math.abs(ref) + Math.abs(yValues[i + 1][j + 1]), 0.1); double bound = Math.Max(Math.Abs(@ref) + Math.Abs(yValues[i + 1][j + 1]), 0.1); ArgChecker.isTrue(Math.Abs(@ref - yValues[i + 1][j + 1]) < ERROR * bound, "Input is too large/small or data points are too close"); coefMat[i][j] = DoubleMatrix.copyOf(coefMatTmp); } } return(new PiecewisePolynomialResult2D(DoubleArray.copyOf(x0Values), DoubleArray.copyOf(x1Values), coefMat, new int[] { order, order })); }
public static double Apply(Permutation assignment, InversionMove move, DoubleMatrix weights, DoubleMatrix distances) { if (move.Index1 == move.Index2) { return(0); } double moveQuality = 0; int min = Math.Min(move.Index1, move.Index2); int max = Math.Max(move.Index1, move.Index2); for (int i = min; i <= max; i++) { int locI = assignment[i]; int newlocI = assignment[max - i + min]; for (int j = 0; j < assignment.Length; j++) { int locJ = assignment[j]; if (j >= min && j <= max) { int newlocJ = assignment[max - j + min]; moveQuality += weights[i, j] * (distances[newlocI, newlocJ] - distances[locI, locJ]); } else { moveQuality += weights[i, j] * (distances[newlocI, locJ] - distances[locI, locJ]); moveQuality += weights[j, i] * (distances[locJ, newlocI] - distances[locJ, locI]); } } } return(moveQuality); }
/// <summary> /// Obtains an instance of the raw data with error for shifted Black (log-normal) volatility. /// </summary> /// <param name="expiries"> the expiries </param> /// <param name="strikes"> the strikes-like data </param> /// <param name="strikeType"> the value type of the strike-like dimension </param> /// <param name="data"> the data </param> /// <param name="error"> the error </param> /// <param name="shift"> the shift </param> /// <returns> the instance </returns> public static RawOptionData ofBlackVolatility(IList <Period> expiries, DoubleArray strikes, ValueType strikeType, DoubleMatrix data, DoubleMatrix error, double?shift) { ArgChecker.isTrue(expiries.Count == data.rowCount(), "expiries list should be of the same size as the external data dimension"); for (int i = 0; i < expiries.Count; i++) { ArgChecker.isTrue(strikes.size() == data.columnCount(), "strikes should be of the same size as the inner data dimension"); } return(new RawOptionData(expiries, strikes, strikeType, data, error, ValueType.BLACK_VOLATILITY, shift)); }
public void Load(TSPData data) { if (data.Coordinates == null && data.Distances == null) { throw new System.IO.InvalidDataException("The given instance specifies neither coordinates nor distances!"); } if (data.Dimension > DistanceMatrixSizeLimit && (data.DistanceMeasure == DistanceMeasure.Att || data.DistanceMeasure == DistanceMeasure.Manhattan || data.DistanceMeasure == DistanceMeasure.Maximum)) { throw new System.IO.InvalidDataException("The given instance uses an unsupported distance measure and is too large for using a distance matrix."); } if (data.Coordinates != null && data.Coordinates.GetLength(1) != 2) { throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates."); } Name = data.Name; Description = data.Description; bool clearCoordinates = false, clearDistanceMatrix = false; if (data.Coordinates != null && data.Coordinates.GetLength(0) > 0) { Coordinates = new DoubleMatrix(data.Coordinates); } else { clearCoordinates = true; } TSPEvaluator evaluator; if (data.DistanceMeasure == DistanceMeasure.Att || data.DistanceMeasure == DistanceMeasure.Manhattan || data.DistanceMeasure == DistanceMeasure.Maximum) { evaluator = new TSPDistanceMatrixEvaluator(); UseDistanceMatrix = new BoolValue(true); DistanceMatrix = new DistanceMatrix(data.GetDistanceMatrix()); } else if (data.DistanceMeasure == DistanceMeasure.Direct && data.Distances != null) { evaluator = new TSPDistanceMatrixEvaluator(); UseDistanceMatrix = new BoolValue(true); DistanceMatrix = new DistanceMatrix(data.Distances); } else { clearDistanceMatrix = true; UseDistanceMatrix = new BoolValue(data.Dimension <= DistanceMatrixSizeLimit); switch (data.DistanceMeasure) { case DistanceMeasure.Euclidean: evaluator = new TSPEuclideanPathEvaluator(); break; case DistanceMeasure.RoundedEuclidean: evaluator = new TSPRoundedEuclideanPathEvaluator(); break; case DistanceMeasure.UpperEuclidean: evaluator = new TSPUpperEuclideanPathEvaluator(); break; case DistanceMeasure.Geo: evaluator = new TSPGeoPathEvaluator(); break; default: throw new InvalidDataException("An unknown distance measure is given in the instance!"); } } evaluator.QualityParameter.ActualName = "TSPTourLength"; Evaluator = evaluator; // reset them after assigning the evaluator if (clearCoordinates) { Coordinates = null; } if (clearDistanceMatrix) { DistanceMatrix = null; } BestKnownSolution = null; BestKnownQuality = null; if (data.BestKnownTour != null) { try { EvaluateAndLoadTour(data.BestKnownTour); } catch (InvalidOperationException) { if (data.BestKnownQuality.HasValue) { BestKnownQuality = new DoubleValue(data.BestKnownQuality.Value); } } } else if (data.BestKnownQuality.HasValue) { BestKnownQuality = new DoubleValue(data.BestKnownQuality.Value); } OnReset(); }
public void SolveMatrix() { DoubleMatrix b = new DoubleMatrix(3); b[0, 0] = 2; b[0, 1] = 2; b[0, 2] = 2; b[1, 0] = 13; b[1, 1] = 13; b[1, 2] = 13; b[2, 0] = 25; b[2, 1] = 25; b[2, 2] = 25; DoubleMatrix x = qr.Solve(b); Assert.AreEqual(x[0, 0], 2.965, TOLERENCE); Assert.AreEqual(x[0, 1], 2.965, TOLERENCE); Assert.AreEqual(x[0, 2], 2.965, TOLERENCE); Assert.AreEqual(x[1, 0], -0.479, TOLERENCE); Assert.AreEqual(x[1, 1], -0.479, TOLERENCE); Assert.AreEqual(x[1, 2], -0.479, TOLERENCE); Assert.AreEqual(x[2, 0], 1.227, TOLERENCE); Assert.AreEqual(x[2, 1], 1.227, TOLERENCE); Assert.AreEqual(x[2, 2], 1.227, TOLERENCE); b = new DoubleMatrix(3, 2); b[0, 0] = 2; b[0, 1] = 2; b[1, 0] = 13; b[1, 1] = 13; b[2, 0] = 25; b[2, 1] = 25; x = qr.Solve(b); Assert.AreEqual(x[0, 0], 2.965, TOLERENCE); Assert.AreEqual(x[0, 1], 2.965, TOLERENCE); Assert.AreEqual(x[1, 0], -0.479, TOLERENCE); Assert.AreEqual(x[1, 1], -0.479, TOLERENCE); Assert.AreEqual(x[2, 0], 1.227, TOLERENCE); Assert.AreEqual(x[2, 1], 1.227, TOLERENCE); b = new DoubleMatrix(3, 4); b[0, 0] = 2; b[0, 1] = 2; b[0, 2] = 2; b[0, 3] = 2; b[1, 0] = 13; b[1, 1] = 13; b[1, 2] = 13; b[1, 3] = 13; b[2, 0] = 25; b[2, 1] = 25; b[2, 2] = 25; b[2, 3] = 25; x = qr.Solve(b); Assert.AreEqual(x[0, 0], 2.965, TOLERENCE); Assert.AreEqual(x[0, 1], 2.965, TOLERENCE); Assert.AreEqual(x[0, 2], 2.965, TOLERENCE); Assert.AreEqual(x[0, 3], 2.965, TOLERENCE); Assert.AreEqual(x[1, 0], -0.479, TOLERENCE); Assert.AreEqual(x[1, 1], -0.479, TOLERENCE); Assert.AreEqual(x[1, 2], -0.479, TOLERENCE); Assert.AreEqual(x[1, 3], -0.479, TOLERENCE); Assert.AreEqual(x[2, 0], 1.227, TOLERENCE); Assert.AreEqual(x[2, 1], 1.227, TOLERENCE); Assert.AreEqual(x[2, 2], 1.227, TOLERENCE); Assert.AreEqual(x[2, 3], 1.227, TOLERENCE); DoubleMatrix A = new DoubleMatrix(4, 3); A[0, 0] = -4.18; A[0, 1] = -5.011; A[0, 2] = -5.841; A[1, 0] = 4.986; A[1, 1] = 5.805; A[1, 2] = 6.624; A[2, 0] = 3.695; A[2, 1] = 3.687; A[2, 2] = 3.679; A[3, 0] = -5.489; A[3, 1] = -7.024; A[3, 2] = 8.56; DoubleQRDecomp qrd = new DoubleQRDecomp(A); DoubleMatrix B = new DoubleMatrix(4, 1); B[0, 0] = 1; B[1, 0] = 4; B[2, 0] = 2; B[3, 0] = 1; x = qrd.Solve(B); Assert.AreEqual(x[0, 0], 2.73529, TOLERENCE); Assert.AreEqual(x[1, 0], -2.15822, TOLERENCE); Assert.AreEqual(x[2, 0], 0.0998564, TOLERENCE); B = new DoubleMatrix(4, 3); B[0, 0] = 1; B[1, 0] = 4; B[2, 0] = 2; B[3, 0] = 1; B[0, 1] = 1; B[1, 1] = 4; B[2, 1] = 2; B[3, 1] = 1; B[0, 2] = 1; B[1, 2] = 4; B[2, 2] = 2; B[3, 2] = 1; x = qrd.Solve(B); Assert.AreEqual(x[0, 0], 2.73529, TOLERENCE); Assert.AreEqual(x[1, 0], -2.15822, TOLERENCE); Assert.AreEqual(x[2, 0], 0.0998564, TOLERENCE); Assert.AreEqual(x[0, 1], 2.73529, TOLERENCE); Assert.AreEqual(x[1, 1], -2.15822, TOLERENCE); Assert.AreEqual(x[2, 1], 0.0998564, TOLERENCE); Assert.AreEqual(x[0, 2], 2.73529, TOLERENCE); Assert.AreEqual(x[1, 2], -2.15822, TOLERENCE); Assert.AreEqual(x[2, 2], 0.0998564, TOLERENCE); }
public void Main() { // Create the context. var context = new RareShortestPathProbabilityEstimation(); // Create the estimator. var estimator = new RareEventProbabilityEstimator() { PerformanceEvaluationParallelOptions = { MaxDegreeOfParallelism = 1 }, SampleGenerationParallelOptions = { MaxDegreeOfParallelism = 1 } }; // Set estimation parameters. double rarity = 0.1; int sampleSize = 1000; int finalSampleSize = 10000; // Solve the problem. var results = estimator.Estimate( context, rarity, sampleSize, finalSampleSize); // Show the results. Console.WriteLine("Under the nominal parameter:"); Console.WriteLine(context.InitialParameter); Console.WriteLine("the estimated probability of observing"); Console.WriteLine("a shortest path greater than 2.0 is:"); Console.WriteLine(results.RareEventProbability); Console.WriteLine(); Console.WriteLine("Details on iterations:"); var info = DoubleMatrix.Dense( -1 + results.Parameters.Count, 1 + results.Parameters.Last.Value.Count); info.SetColumnName(0, "Level"); for (int j = 1; j < info.NumberOfColumns; j++) { info.SetColumnName(j, "Param" + (j - 1).ToString()); } int i = 0; foreach (var level in results.Levels) { info[i++, 0] = level; } var referenceParameters = results.Parameters.Skip(1).ToList(); var paramIndexes = IndexCollection.Range(1, info.NumberOfColumns - 1); for (i = 0; i < info.NumberOfRows; i++) { info[i, paramIndexes] = referenceParameters[i]; } Console.WriteLine(); Console.WriteLine(info); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance of the raw volatility. /// <para> /// The data values can be model parameters (like Black or normal volatilities) or direct option prices. /// /// </para> /// </summary> /// <param name="expiries"> the expiries </param> /// <param name="strikes"> the strikes-like data </param> /// <param name="strikeType"> the value type of the strike-like dimension </param> /// <param name="data"> the data </param> /// <param name="dataType"> the data type </param> /// <returns> the instance </returns> public static RawOptionData of(IList <Period> expiries, DoubleArray strikes, ValueType strikeType, DoubleMatrix data, ValueType dataType) { ArgChecker.isTrue(expiries.Count == data.rowCount(), "expiries list should be of the same size as the external data dimension"); for (int i = 0; i < expiries.Count; i++) { ArgChecker.isTrue(strikes.size() == data.columnCount(), "strikes should be of the same size as the inner data dimension"); } return(new RawOptionData(expiries, strikes, strikeType, data, null, dataType, 0.0)); }
public virtual void sensitivity_multi_combined_curve() { CrossGammaParameterSensitivities sensiCrossComputed = CENTRAL.calculateCrossGammaCrossCurve(RatesProviderDataSets.MULTI_CPI_USD_COMBINED, this.sensiCombinedFn); DoubleArray times1 = RatesProviderDataSets.TIMES_1; // ois DoubleArray times2 = RatesProviderDataSets.TIMES_2; // l3 DoubleArray times3 = RatesProviderDataSets.TIMES_3; // l6 DoubleArray times4 = RatesProviderDataSets.TIMES_4; // cpi int paramsTotal = times1.size() + times2.size() + times3.size() + times4.size(); double[] timesTotal = new double[paramsTotal]; DoubleArray times1Twice = times1.multipliedBy(2d); Array.Copy(times4.toArray(), 0, timesTotal, 0, times4.size()); Array.Copy(times1Twice.toArray(), 0, timesTotal, times4.size(), times1.size()); Array.Copy(times2.toArray(), 0, timesTotal, times1.size() + times4.size(), times2.size()); Array.Copy(times3.toArray(), 0, timesTotal, times1.size() + times2.size() + times4.size(), times3.size()); assertEquals(sensiCrossComputed.size(), 4); DoubleMatrix s1 = sensiCrossComputed.getSensitivity(RatesProviderDataSets.USD_DSC_NAME, USD).Sensitivity; assertEquals(s1.columnCount(), paramsTotal); for (int i = 0; i < times1.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 4d * times1.get(i) * timesTotal[j]; assertEquals(s1.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s2 = sensiCrossComputed.getSensitivity(RatesProviderDataSets.USD_L3_NAME, USD).Sensitivity; assertEquals(s2.columnCount(), paramsTotal); for (int i = 0; i < times2.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 8d * times2.get(i) * timesTotal[j]; assertEquals(s2.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s3 = sensiCrossComputed.getSensitivity(RatesProviderDataSets.USD_L6_NAME, USD).Sensitivity; assertEquals(s3.columnCount(), paramsTotal); for (int i = 0; i < times3.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 2d * times3.get(i) * timesTotal[j]; assertEquals(s3.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s4 = sensiCrossComputed.getSensitivity(RatesProviderDataSets.USD_CPI_NAME, USD).Sensitivity; assertEquals(s4.columnCount(), paramsTotal); for (int i = 0; i < times4.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 2d * times4.get(i) * timesTotal[j]; assertEquals(s4.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 20d); } } CrossGammaParameterSensitivities sensiIntraComputed = CENTRAL.calculateCrossGammaIntraCurve(RatesProviderDataSets.MULTI_CPI_USD_COMBINED, this.sensiCombinedFn); DoubleMatrix s1Intra = sensiIntraComputed.getSensitivity(RatesProviderDataSets.USD_DSC_NAME, USD).Sensitivity; DoubleMatrix s2Intra = sensiIntraComputed.getSensitivity(RatesProviderDataSets.USD_L3_NAME, USD).Sensitivity; DoubleMatrix s3Intra = sensiIntraComputed.getSensitivity(RatesProviderDataSets.USD_L6_NAME, USD).Sensitivity; DoubleMatrix s4Intra = sensiIntraComputed.getSensitivity(RatesProviderDataSets.USD_CPI_NAME, USD).Sensitivity; int offsetOis = times4.size(); for (int i = 0; i < times1.size(); i++) { for (int j = 0; j < times1.size(); j++) { assertEquals(s1Intra.get(i, j), s1.get(i, offsetOis + j), TOL); } } int offset3m = times4.size() + times1.size(); for (int i = 0; i < times2.size(); i++) { for (int j = 0; j < times2.size(); j++) { assertEquals(s2Intra.get(i, j), s2.get(i, offset3m + j), TOL); } } int offset6m = times4.size() + times1.size() + times2.size(); for (int i = 0; i < times3.size(); i++) { for (int j = 0; j < times3.size(); j++) { assertEquals(s3Intra.get(i, j), s3.get(i, offset6m + j), TOL); } } for (int i = 0; i < times4.size(); i++) { for (int j = 0; j < times4.size(); j++) { assertEquals(s4Intra.get(i, j), s4.get(i, j), TOL); } } }
public static void SubstractScalarsByDims(ref DoubleMatrix io_leftHandMatrix, DoubleMatrix i_rightHandVector) { if ((i_rightHandVector.ColumnsCount > 1) || (io_leftHandMatrix.RowsCount != i_rightHandVector.RowsCount)) { throw new PCAException("Dimension are not meet for substraction of a vector from matrix by rows"); } Func <int, int, double, double> substractByDim = (row, col, Val) => (Val - (double)i_rightHandVector[row, 0]); io_leftHandMatrix.Iterate(substractByDim); }
protected override void DrawVisualization(Bitmap bitmap) { DoubleMatrix coordinates = Content.Coordinates; DoubleMatrix distanceMatrix = Content.DistanceMatrix; BoolValue useDistanceMatrix = Content.UseDistanceMatrix; DoubleArray dueTime = Content.DueTime; DoubleArray serviceTime = Content.ServiceTime; DoubleArray readyTime = Content.ReadyTime; if ((coordinates != null) && (coordinates.Rows > 0) && (coordinates.Columns == 2)) { double xMin = double.MaxValue, yMin = double.MaxValue, xMax = double.MinValue, yMax = double.MinValue; for (int i = 0; i < coordinates.Rows; i++) { if (xMin > coordinates[i, 0]) { xMin = coordinates[i, 0]; } if (yMin > coordinates[i, 1]) { yMin = coordinates[i, 1]; } if (xMax < coordinates[i, 0]) { xMax = coordinates[i, 0]; } if (yMax < coordinates[i, 1]) { yMax = coordinates[i, 1]; } } int border = 20; double xStep = xMax != xMin ? (bitmap.Width - 2 * border) / (xMax - xMin) : 1; double yStep = yMax != yMin ? (bitmap.Height - 2 * border) / (yMax - yMin) : 1; using (Graphics graphics = Graphics.FromImage(bitmap)) { if (Solution != null) { int currentTour = 0; List <Tour> tours = Solution.GetTours(); List <Pen> pens = GetColors(tours.Count); foreach (Tour tour in tours) { double t = 0.0; Point[] tourPoints = new Point[tour.Stops.Count + 2]; Brush[] customerBrushes = new Brush[tour.Stops.Count]; int lastCustomer = 0; for (int i = -1; i <= tour.Stops.Count; i++) { int location = 0; if (i == -1 || i == tour.Stops.Count) { location = 0; //depot } else { location = tour.Stops[i]; } Point locationPoint = new Point(border + ((int)((coordinates[location, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((coordinates[location, 1] - yMin) * yStep)))); tourPoints[i + 1] = locationPoint; if (i != -1 && i != tour.Stops.Count) { Brush customerBrush = Brushes.Black; t += Content.GetDistance( lastCustomer, location, Solution); if (t < readyTime[location]) { t = readyTime[location]; customerBrush = Brushes.Orange; } else if (t > dueTime[location]) { customerBrush = Brushes.Red; } t += serviceTime[location]; customerBrushes[i] = customerBrush; } lastCustomer = location; } graphics.DrawPolygon(pens[currentTour], tourPoints); for (int i = 0; i < tour.Stops.Count; i++) { graphics.FillRectangle(customerBrushes[i], tourPoints[i + 1].X - 3, tourPoints[i + 1].Y - 3, 6, 6); } graphics.FillEllipse(Brushes.Blue, tourPoints[0].X - 5, tourPoints[0].Y - 5, 10, 10); currentTour++; } for (int i = 0; i < pens.Count; i++) { pens[i].Dispose(); } } else { Point locationPoint; //just draw customers for (int i = 1; i < coordinates.Rows; i++) { locationPoint = new Point(border + ((int)((coordinates[i, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((coordinates[i, 1] - yMin) * yStep)))); graphics.FillRectangle(Brushes.Black, locationPoint.X - 3, locationPoint.Y - 3, 6, 6); } locationPoint = new Point(border + ((int)((coordinates[0, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((coordinates[0, 1] - yMin) * yStep)))); graphics.FillEllipse(Brushes.Blue, locationPoint.X - 5, locationPoint.Y - 5, 10, 10); } } } }
protected override void DrawVisualization(Bitmap bitmap) { DoubleMatrix coordinates = Content.Coordinates; DoubleMatrix distanceMatrix = Content.DistanceMatrix; BoolValue useDistanceMatrix = Content.UseDistanceMatrix; if ((coordinates != null) && (coordinates.Rows > 0) && (coordinates.Columns == 2)) { double xMin = double.MaxValue, yMin = double.MaxValue, xMax = double.MinValue, yMax = double.MinValue; for (int i = 0; i < coordinates.Rows; i++) { if (xMin > coordinates[i, 0]) { xMin = coordinates[i, 0]; } if (yMin > coordinates[i, 1]) { yMin = coordinates[i, 1]; } if (xMax < coordinates[i, 0]) { xMax = coordinates[i, 0]; } if (yMax < coordinates[i, 1]) { yMax = coordinates[i, 1]; } } int border = 20; double xStep = xMax != xMin ? (bitmap.Width - 2 * border) / (xMax - xMin) : 1; double yStep = yMax != yMin ? (bitmap.Height - 2 * border) / (yMax - yMin) : 1; using (Graphics graphics = Graphics.FromImage(bitmap)) { if (Solution != null) { for (int i = 0; i < Content.Depots.Value; i++) { Point locationPoint = new Point(border + ((int)((coordinates[i, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((coordinates[i, 1] - yMin) * yStep)))); graphics.FillEllipse(Brushes.Blue, locationPoint.X - 5, locationPoint.Y - 5, 10, 10); } int currentTour = 0; List <Tour> tours = Solution.GetTours(); List <Pen> pens = GetColors(tours.Count); foreach (Tour tour in tours) { Point[] tourPoints = new Point[tour.Stops.Count + 2]; Brush[] customerBrushes = new Brush[tour.Stops.Count]; int lastCustomer = 0; for (int i = -1; i <= tour.Stops.Count; i++) { int location = 0; if (i == -1 || i == tour.Stops.Count) { location = 0; //depot } else { location = tour.Stops[i]; } Point locationPoint; if (location == 0) { int tourIndex = Solution.GetTourIndex(tour); int vehicle = Solution.GetVehicleAssignment(tourIndex); int depot = Content.VehicleDepotAssignment[vehicle]; locationPoint = new Point(border + ((int)((Content.Coordinates[depot, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((Content.Coordinates[depot, 1] - yMin) * yStep)))); } else { locationPoint = new Point(border + ((int)((Content.GetCoordinates(location)[0] - xMin) * xStep)), bitmap.Height - (border + ((int)((Content.GetCoordinates(location)[1] - yMin) * yStep)))); } tourPoints[i + 1] = locationPoint; if (i != -1 && i != tour.Stops.Count) { Brush customerBrush = Brushes.Black; customerBrushes[i] = customerBrush; } lastCustomer = location; } graphics.DrawPolygon(pens[currentTour], tourPoints); for (int i = 0; i < tour.Stops.Count; i++) { graphics.FillRectangle(customerBrushes[i], tourPoints[i + 1].X - 3, tourPoints[i + 1].Y - 3, 6, 6); } graphics.FillEllipse(Brushes.DarkBlue, tourPoints[0].X - 5, tourPoints[0].Y - 5, 10, 10); currentTour++; } for (int i = 0; i < pens.Count; i++) { pens[i].Dispose(); } } else { Point locationPoint; //just draw customers for (int i = 1; i <= Content.Cities.Value; i++) { locationPoint = new Point(border + ((int)((Content.GetCoordinates(i)[0] - xMin) * xStep)), bitmap.Height - (border + ((int)((Content.GetCoordinates(i)[1] - yMin) * yStep)))); graphics.FillRectangle(Brushes.Black, locationPoint.X - 3, locationPoint.Y - 3, 6, 6); } for (int i = 0; i < Content.Depots.Value; i++) { locationPoint = new Point(border + ((int)((coordinates[i, 0] - xMin) * xStep)), bitmap.Height - (border + ((int)((coordinates[i, 1] - yMin) * yStep)))); graphics.FillEllipse(Brushes.Blue, locationPoint.X - 5, locationPoint.Y - 5, 10, 10); } } } } }
public LAPAssignment(DoubleMatrix costs, Permutation assignment, DoubleValue quality) : this(costs, assignment) { this.quality = quality; }
public static AdditiveMove[] Apply(IRandom random, RealVector vector, double contiguity, int sampleSize, double maxManipulation, DoubleMatrix bounds) { AdditiveMove[] moves = new AdditiveMove[sampleSize]; for (int i = 0; i < sampleSize; i++) { int index = random.Next(vector.Length); double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1]; do { strength = PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation; } while (vector[index] + strength <min || vector[index] + strength> max); moves[i] = new AdditiveMove(index, strength); } return(moves); }
public LAPAssignment(DoubleMatrix costs, StringArray rowNames, StringArray columnNames, Permutation assignment, DoubleValue quality) : this(costs, rowNames, columnNames, assignment) { this.quality = quality; }
protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds) { return(Apply(random, realVector, ContiguityParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, MaximumManipulationParameter.ActualValue.Value, bounds)); }
private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames) { DoubleMatrix matrix = null; IEnumerable <DoubleMatrix> allVariableImpacts = (from run in runs select run.Results[variableImpactResultName]).Cast <DoubleMatrix>(); IEnumerable <string> variableNames = (from variableImpact in allVariableImpacts from variableName in variableImpact.RowNames select variableName) .Distinct(); // filter variableNames: only include names that have at least one non-zero value in a run List <string> variableNamesList = (from variableName in variableNames where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0)) select variableName) .ToList(); List <string> statictics = new List <string> { "Median Rank", "Mean", "StdDev", "pValue" }; List <string> columnNames = new List <string>(runNames); columnNames.AddRange(statictics); int numberOfRuns = runs.Length; matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + statictics.Count); matrix.SortableView = true; matrix.ColumnNames = columnNames; // calculate statistics List <List <double> > variableImpactsOverRuns = (from variableName in variableNamesList select GetVariableImpacts(variableName, allVariableImpacts).ToList()) .ToList(); List <List <double> > variableRanks = (from variableName in variableNamesList select GetVariableImpactRanks(variableName, allVariableImpacts).ToList()) .ToList(); if (variableImpactsOverRuns.Count() > 0) { // the variable with the worst median impact value is chosen as the reference variable // this is problematic if all variables are relevant, however works often in practice List <double> referenceImpacts = (from impacts in variableImpactsOverRuns let avg = impacts.Median() orderby avg select impacts) .First(); // for all variables for (int row = 0; row < variableImpactsOverRuns.Count; row++) { // median rank matrix[row, numberOfRuns] = variableRanks[row].Median(); // also show mean and std.dev. of relative variable impacts to indicate the relative difference in impacts of variables matrix[row, numberOfRuns + 1] = Math.Round(variableImpactsOverRuns[row].Average(), 3); matrix[row, numberOfRuns + 2] = Math.Round(variableImpactsOverRuns[row].StandardDeviation(), 3); double leftTail = 0; double rightTail = 0; double bothTails = 0; // calc differences of impacts for current variable and reference variable double[] z = new double[referenceImpacts.Count]; for (int i = 0; i < z.Length; i++) { z[i] = variableImpactsOverRuns[row][i] - referenceImpacts[i]; } // wilcoxon signed rank test is used because the impact values of two variables in a single run are not independent alglib.wsr.wilcoxonsignedranktest(z, z.Length, 0, ref bothTails, ref leftTail, ref rightTail); matrix[row, numberOfRuns + 3] = Math.Round(bothTails, 4); } } // fill matrix with impacts from runs for (int i = 0; i < runs.Length; i++) { IRun run = runs[i]; DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName]; for (int j = 0; j < runVariableImpacts.Rows; j++) { int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j)); if (rowIndex > -1) { matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3); } } } // sort by median var sortedMatrix = (DoubleMatrix)matrix.Clone(); var sortedIndexes = from i in Enumerable.Range(0, sortedMatrix.Rows) orderby matrix[i, numberOfRuns] select i; int targetIndex = 0; foreach (var sourceIndex in sortedIndexes) { for (int c = 0; c < matrix.Columns; c++) { sortedMatrix[targetIndex, c] = matrix[sourceIndex, c]; } targetIndex++; } sortedMatrix.RowNames = sortedIndexes.Select(i => variableNamesList[i]); return(sortedMatrix); }
/// <summary> /// Generates a new random real vector normally distributed around the given mean with the given <paramref name="length"/> and in the interval [min,max). /// </summary> /// <exception cref="ArgumentException"> /// Thrown when <paramref name="random"/> is null.<br /> /// Thrown when <paramref name="mean"/> is null or of length 0.<br /> /// Thrown when <paramref name="sigma"/> is null or of length 0.<br /> /// </exception> /// <remarks> /// If no bounds are given the bounds will be set to (double.MinValue;double.MaxValue). /// /// If dimensions of the mean do not lie within the given bounds they're set to either to the min or max of the bounds depending on whether the given dimension /// for the mean is smaller or larger than the bounds. If min and max for a certain dimension are almost the same the resulting value will be set to min. /// /// However, please consider that such static bounds are not really meaningful to optimize. /// /// The sigma vector can contain 0 values in which case the dimension will be exactly the same as the given mean. /// </remarks> /// <param name="random">The random number generator.</param> /// <param name="means">The mean vector around which the resulting vector is sampled.</param> /// <param name="sigmas">The vector of standard deviations, must have at least one row.</param> /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param> /// <param name="maximumTries">The maximum number of tries to sample a value inside the bounds for each dimension. If a valid value cannot be obtained, the mean will be used.</param> /// <returns>The newly created real vector.</returns> public static RealVector Apply(IntValue lengthValue, IRandom random, RealVector means, DoubleArray sigmas, DoubleMatrix bounds, int maximumTries = 1000) { if (lengthValue == null || lengthValue.Value == 0) { throw new ArgumentException("Length is not defined or zero"); } if (random == null) { throw new ArgumentNullException("Random is not defined", "random"); } if (means == null || means.Length == 0) { throw new ArgumentNullException("Mean is not defined", "mean"); } if (sigmas == null || sigmas.Length == 0) { throw new ArgumentNullException("Sigma is not defined.", "sigma"); } if (bounds == null || bounds.Rows == 0) { bounds = new DoubleMatrix(new[, ] { { double.MinValue, double.MaxValue } }); } var length = lengthValue.Value; var nd = new NormalDistributedRandom(random, 0, 1); var result = new RealVector(length); for (int i = 0; i < result.Length; i++) { var min = bounds[i % bounds.Rows, 0]; var max = bounds[i % bounds.Rows, 1]; var mean = means[i % means.Length]; var sigma = sigmas[i % sigmas.Length]; if (min.IsAlmost(max) || mean < min) { result[i] = min; } else if (mean > max) { result[i] = max; } else { int count = 0; bool inRange; do { result[i] = mean + sigma * nd.NextDouble(); inRange = result[i] >= min && result[i] < max; count++; } while (count < maximumTries && !inRange); if (count == maximumTries && !inRange) { result[i] = mean; } } } return(result); }
public void SetMassesTest() { // Valid input { var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); var masses = DoubleMatrix.Dense(3, 2, new double[6] { .1, .2, .3, .2, .1, .1 }); distribution.SetMasses(masses: masses); DoubleMatrixAssert.AreEqual( expected: masses, actual: (DoubleMatrix)distribution.Masses, delta: DoubleMatrixTest.Accuracy); } // masses is null { var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); ArgumentExceptionAssert.Throw( () => { distribution.SetMasses(masses: null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "masses"); } // The number of rows in masses is not equal to that of values { string STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS"), "values"); var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); var masses = DoubleMatrix.Dense(1, 2, new double[2] { .5, .5 }); ArgumentExceptionAssert.Throw( () => { distribution.SetMasses(masses: masses); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS, expectedParameterName: "masses"); } // The number of columns in masses is not equal to that of values { string STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS"), "values"); var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); var masses = DoubleMatrix.Dense(3, 1, new double[3] { .2, .5, .3 }); ArgumentExceptionAssert.Throw( () => { distribution.SetMasses(masses: masses); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS, expectedParameterName: "masses"); } // At least an entry in masses is negative { string STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL"), "0", "1"); var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); var masses = DoubleMatrix.Dense(3, 2, new double[6] { .2, .5, .3, -.1, .1, 0 }); ArgumentExceptionAssert.Throw( () => { distribution.SetMasses(masses: masses); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL, expectedParameterName: "masses"); } // The sum of the masses is not 1 { string STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1 = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1"); var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform( values: values); var masses = DoubleMatrix.Dense(3, 2, new double[6] { .2, .5, .3, .1, .1, 0 }); ArgumentExceptionAssert.Throw( () => { distribution.SetMasses(masses: masses); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1, expectedParameterName: "masses"); } }
/// <summary> /// Forwards the call to <see cref="Apply(IRandom, RealVector, DoubleArray, DoubleMatrix)"/>. /// </summary> /// <param name="random">The pseudo random number generator to use.</param> /// <param name="length">The length of the real vector.</param> /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param> /// <returns>The newly created real vector.</returns> protected override RealVector Create(IRandom random, IntValue length, DoubleMatrix bounds) { return(Apply(length, random, MeanParameter.ActualValue, SigmaParameter.ActualValue, bounds, MaximumTriesParameter.Value.Value)); }
/// <summary> /// Runs this Cross-Entropy program designed to estimate /// the probability of the specified rare event context. /// </summary> /// <param name="context">The context in which the rare event /// probability must be estimated.</param> /// <param name="rarity">The rarity applied by the Cross-Entropy method.</param> /// <param name="sampleSize">The size of the samples drawn during the /// sampling step of the Cross-Entropy method.</param> /// <param name="estimationSampleSize">The size of the sample drawn to /// estimate the rare event probability.</param> /// <returns>The results of the Cross-Entropy estimator.</returns> /// <remarks> /// <para> /// For a thorough description of the method and an example /// of how to use it, /// see the remarks /// about the /// <see cref="RareEventProbabilityEstimationContext"/> class. /// </para> /// </remarks> /// <exception cref="ArgumentNullException"> /// <paramref name="context"/> is <b>null</b>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="sampleSize"/> is not positive.<br/> /// -or-<br/> /// <paramref name="rarity"/> is not positive.<br/> /// -or-<br/> /// <paramref name="rarity"/> is not less than 1.<br/> /// -or-<br/> /// <paramref name="estimationSampleSize"/> is not positive. /// </exception> public RareEventProbabilityEstimationResults Estimate( RareEventProbabilityEstimationContext context, double rarity, int sampleSize, int estimationSampleSize) { if (estimationSampleSize < 1) { throw new ArgumentOutOfRangeException( nameof(estimationSampleSize), ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE")); } var baseResults = base.Run( context, sampleSize, rarity); var results = new RareEventProbabilityEstimationResults { Levels = baseResults.Levels, Parameters = baseResults.Parameters, HasConverged = true }; DoubleMatrix optimalParameter = results.Parameters.Last.Value; DoubleMatrix finalSample = this.Sample( context, estimationSampleSize, optimalParameter); var finalPerformances = this.EvaluatePerformances(context, finalSample); Predicate <double> match; if (context.EliteSampleDefinition == EliteSampleDefinition.LowerThanLevel) { match = (p) => { return(p <= context.ThresholdLevel); }; } else { match = (p) => { return(p >= context.ThresholdLevel); }; } var excessIndexes = finalPerformances.FindWhile(match); var ratios = DoubleMatrix.Dense(1, estimationSampleSize); var nominalParameter = context.InitialParameter; for (int i = 0; i < estimationSampleSize; i++) { var samplePoint = finalSample[i, ":"]; ratios[i] = context.GetLikelihoodRatio( samplePoint, nominalParameter, optimalParameter); } double rareEventProbability = Stat.Sum(ratios.Vec(excessIndexes)) / Convert.ToDouble(estimationSampleSize); results.RareEventProbability = rareEventProbability; return(results); }
public virtual void sensitivity_cross_multi_curve() { CrossGammaParameterSensitivities sensiComputed = CENTRAL.calculateCrossGammaCrossCurve(RatesProviderDataSets.MULTI_CPI_USD, this.sensiFn); DoubleArray times1 = RatesProviderDataSets.TIMES_1; DoubleArray times2 = RatesProviderDataSets.TIMES_2; DoubleArray times3 = RatesProviderDataSets.TIMES_3; DoubleArray times4 = RatesProviderDataSets.TIMES_4; int paramsTotal = times1.size() + times2.size() + times3.size() + times4.size(); double[] timesTotal = new double[paramsTotal]; DoubleArray times1Twice = times1.multipliedBy(2d); Array.Copy(times4.toArray(), 0, timesTotal, 0, times4.size()); Array.Copy(times1Twice.toArray(), 0, timesTotal, times4.size(), times1.size()); Array.Copy(times2.toArray(), 0, timesTotal, times1.size() + times4.size(), times2.size()); Array.Copy(times3.toArray(), 0, timesTotal, times1.size() + times2.size() + times4.size(), times3.size()); assertEquals(sensiComputed.size(), 4); DoubleMatrix s1 = sensiComputed.getSensitivity(RatesProviderDataSets.USD_DSC_NAME, USD).Sensitivity; assertEquals(s1.columnCount(), paramsTotal); for (int i = 0; i < times1.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 4d * times1.get(i) * timesTotal[j]; assertEquals(s1.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s2 = sensiComputed.getSensitivity(RatesProviderDataSets.USD_L3_NAME, USD).Sensitivity; assertEquals(s2.columnCount(), paramsTotal); for (int i = 0; i < times2.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 2d * times2.get(i) * timesTotal[j]; assertEquals(s2.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s3 = sensiComputed.getSensitivity(RatesProviderDataSets.USD_L6_NAME, USD).Sensitivity; assertEquals(s3.columnCount(), paramsTotal); for (int i = 0; i < times3.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 2d * times3.get(i) * timesTotal[j]; assertEquals(s3.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 10d); } } DoubleMatrix s4 = sensiComputed.getSensitivity(RatesProviderDataSets.USD_CPI_NAME, USD).Sensitivity; assertEquals(s4.columnCount(), paramsTotal); for (int i = 0; i < times4.size(); i++) { for (int j = 0; j < paramsTotal; j++) { double expected = 2d * times4.get(i) * timesTotal[j]; assertEquals(s4.get(i, j), expected, Math.Max(Math.Abs(expected), 1d) * EPS * 20d); } } }
public override IOperation Apply() { DoubleMatrix distances = DistancesParameter.ActualValue; DoubleMatrix weights = WeightsParameter.ActualValue; ItemArray <Permutation> permutations = PermutationParameter.ActualValue; ItemArray <DoubleValue> qualities = QualityParameter.ActualValue; ResultCollection results = ResultsParameter.ActualValue; bool max = MaximizationParameter.ActualValue.Value; DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue; var sorted = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).ToArray(); if (max) { sorted = sorted.Reverse().ToArray(); } int i = sorted.First().index; if (bestKnownQuality == null || max && qualities[i].Value > bestKnownQuality.Value || !max && qualities[i].Value < bestKnownQuality.Value) { // if there isn't a best-known quality or we improved the best-known quality we'll add the current solution as best-known BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value); BestKnownSolutionParameter.ActualValue = (Permutation)permutations[i].Clone(); BestKnownSolutionsParameter.ActualValue = new ItemSet <Permutation>(new PermutationEqualityComparer()); BestKnownSolutionsParameter.ActualValue.Add((Permutation)permutations[i].Clone()); } else if (bestKnownQuality.Value == qualities[i].Value) { // if we matched the best-known quality we'll try to set the best-known solution if it isn't null // and try to add it to the pool of best solutions if it is different if (BestKnownSolutionParameter.ActualValue == null) { BestKnownSolutionParameter.ActualValue = (Permutation)permutations[i].Clone(); } if (BestKnownSolutionsParameter.ActualValue == null) { BestKnownSolutionsParameter.ActualValue = new ItemSet <Permutation>(new PermutationEqualityComparer()); } foreach (var k in sorted) // for each solution that we found check if it is in the pool of best-knowns { if (!max && k.Value > qualities[i].Value || max && k.Value < qualities[i].Value) { break; // stop when we reached a solution worse than the best-known quality } Permutation p = permutations[k.index]; if (!BestKnownSolutionsParameter.ActualValue.Contains(p)) { BestKnownSolutionsParameter.ActualValue.Add((Permutation)permutations[k.index].Clone()); } } } QAPAssignment assignment = BestSolutionParameter.ActualValue; if (assignment == null) { assignment = new QAPAssignment(weights, (Permutation)permutations[i].Clone(), new DoubleValue(qualities[i].Value)); assignment.Distances = distances; BestSolutionParameter.ActualValue = assignment; results.Add(new Result("Best QAP Solution", assignment)); } else { if (max && assignment.Quality.Value < qualities[i].Value || !max && assignment.Quality.Value > qualities[i].Value) { assignment.Distances = distances; assignment.Weights = weights; assignment.Assignment = (Permutation)permutations[i].Clone(); assignment.Quality.Value = qualities[i].Value; } } return(base.Apply()); }
private RawOptionData(IList <Period> expiries, DoubleArray strikes, ValueType strikeType, DoubleMatrix data, DoubleMatrix error, ValueType dataType, double?shift) { JodaBeanUtils.notNull(expiries, "expiries"); JodaBeanUtils.notNull(strikes, "strikes"); JodaBeanUtils.notNull(strikeType, "strikeType"); JodaBeanUtils.notNull(data, "data"); JodaBeanUtils.notNull(dataType, "dataType"); this.expiries = ImmutableList.copyOf(expiries); this.strikes = strikes; this.strikeType = strikeType; this.data = data; this.error = error; this.dataType = dataType; this.shift = shift; }