public override double Next() { while (true) { double eta = T.d_rev(_unif.Generate()); double xi = Distribution.runif(0, T.p(eta)); if (xi <= T.g2(eta)) { return(eta); } } }
public void GenerateTest() { UniformContinuousDistribution target = new UniformContinuousDistribution(2, 5); double[] samples = target.Generate(1000000); var actual = UniformContinuousDistribution.Estimate(samples); actual.Fit(samples); Assert.AreEqual(2, actual.Minimum, 1e-4); Assert.AreEqual(5, actual.Maximum, 1e-4); }
public override double Next() { if (_unif2.Generate() < 1) { return(RndC1()); } double rval; do { rval = RndC2(); }while (rval < T.X2); return(rval); }
public override double Next() { while (true) { double eta = T.d_rev(_unif.Generate()) / _d; if (eta > T.X1 && eta < T.X2) { double xi = Distribution.runif(0, T.p(eta)); if (xi < T.g(eta)) { return(eta); } } } }
public Bootstrap(int n, Distribution distr) { N = n; _distr = distr; _nRev = 1.0 / N; var unif = new UniformContinuousDistribution(); X = distr.d_rev(unif.Generate(N)).OrderBy(x => x).ToArray(); Probabilities = X.Select(GetProbailities).ToArray().CumulativeSum(); _tree = new BST(); for (int i = 0; i < Probabilities.Length; i++) { _tree.Add(Probabilities[i], X[i]); } }
public void GenerateTest2() { UniformContinuousDistribution target = new UniformContinuousDistribution(-1, 4); double[] samples = new double[1000000]; for (int i = 0; i < samples.Length; i++) { samples[i] = target.Generate(); } var actual = UniformContinuousDistribution.Estimate(samples); actual.Fit(samples); Assert.AreEqual(-1, actual.Minimum, 1e-4); Assert.AreEqual(4, actual.Maximum, 1e-4); }
public void GenerateTest() { UniformContinuousDistribution target = new UniformContinuousDistribution(0, 2); double[] samples = target.Generate(1000000); for (int i = 0; i < samples.Length; i++) { Assert.IsTrue(samples[i] >= 0); Assert.IsTrue(samples[i] <= 2); } UniformContinuousDistribution newTarget = new UniformContinuousDistribution(); newTarget.Fit(samples); Assert.AreEqual(0, newTarget.Minimum, 1e-5); Assert.AreEqual(2, newTarget.Maximum, 1e-5); }
/// <summary> /// Particle states are initialized randomly according to provided ranges <paramref name="ranges"/>. /// </summary> /// <param name="numberOfParticles">Number of particles to create.</param> /// <param name="ranges">Bound for each process state dimension.</param> /// <param name="creator">Function that creates a single particle from floating point array.</param> public static IEnumerable <TParticle> UnifromParticleSpreadInitializer <TParticle>(int numberOfParticles, DoubleRange[] ranges, Func <double[], TParticle> creator) where TParticle : class, IParticle { List <double[]> randomRanges = new List <double[]>(numberOfParticles); for (int pIdx = 0; pIdx < numberOfParticles; pIdx++) { randomRanges.Add(new double[ranges.Length]); } /*************** initialize states by random value ******************/ int stateDimensionIdx = 0; foreach (var range in ranges) { var unifromDistribution = new UniformContinuousDistribution(range.Min, range.Max); for (int pIdx = 0; pIdx < numberOfParticles; pIdx++) { randomRanges[pIdx][stateDimensionIdx] = unifromDistribution.Generate(); } stateDimensionIdx++; } /*************** initialize states by random value ******************/ var particles = new List <TParticle>(numberOfParticles); /**************** make particles *****************/ double initialWeight = 1d / numberOfParticles; for (int i = 0; i < numberOfParticles; i++) { var p = creator(randomRanges[i]); p.Weight = initialWeight; particles.Add(p); } /**************** make particles *****************/ return(particles); }
/// <summary> /// Run a simulation and store the results for later use by <see cref="GetIndices(MarketObservable, List{Date})"/> /// </summary> /// <param name="simNumber"></param> public override void RunSimulation(int simNumber) { _simulation = new Dictionary <int, double>(); var spot = _fxSource.GetRate(_anchorDate); var simRate = spot; var oldFxFwd = spot; double newFXfwd; // Simulate the default var normal = new NormalDistribution(); var uniform = new UniformContinuousDistribution(); var hazEst = _survivalProbSource.GetSP(_survivalProbSource.getAnchorDate().AddTenor(Tenor.FromYears(1))); hazEst = -Math.Log(hazEst); Generator.Seed = -533776581 * simNumber; // This magic number is: "DeterministicCreditWithFXJump".GetHashCode(); var tau = uniform.Generate(); tau = Math.Log(tau) / -hazEst; _simDefaultTime = _anchorDate.value + tau * 365; for (var timeCounter = 0; timeCounter < _allRequiredDates.Count; timeCounter++) { double dt = timeCounter > 0 ? _allRequiredDates[timeCounter] - _allRequiredDates[timeCounter - 1] : _allRequiredDates[timeCounter] - _anchorDate.value; newFXfwd = _fxSource.GetRate(new Date(_anchorDate.value + dt)); dt = dt / 365.0; var sdt = Math.Sqrt(dt); var dW = normal.Generate(); // TODO: drift needs to be adjusted for default rate * jump size simRate = simRate * newFXfwd / oldFxFwd * Math.Exp(-0.5 * _fxVol * _fxVol * dt + _fxVol * sdt * dW); if (_simDefaultTime < _allRequiredDates[timeCounter]) { _simulation[_allRequiredDates[timeCounter]] = simRate * (1 + _relJumpSizeInDefault); } else { _simulation[_allRequiredDates[timeCounter]] = simRate; } } }
/// <summary> /// Run a simulation and store the results for later use by <see cref="GetIndices(MarketObservable, List{Date})"/> /// </summary> /// <param name="simNumber"></param> public override void RunSimulation(int simNumber) { simulation = new Dictionary <int, double>(); double simRate = spot; double oldFxFwd = spot; double newFXfwd; // Simulate the default NormalDistribution normal = new NormalDistribution(); UniformContinuousDistribution uniform = new UniformContinuousDistribution(); double hazEst = survivalProbSource.GetSP(survivalProbSource.getAnchorDate().AddTenor(Tenor.Years(1))); hazEst = -Math.Log(hazEst); Generator.Seed = -533776581 * simNumber; // This magic number is: "DeterministicCreditWithFXJump".GetHashCode(); double tau = uniform.Generate(); tau = Math.Log(tau) / (-hazEst); simDefaultTime = anchorDate.value + tau * 365; for (int timeCounter = 0; timeCounter < allRequiredDates.Count; timeCounter++) { double dt = timeCounter > 0 ? allRequiredDates[timeCounter] - allRequiredDates[timeCounter - 1] : allRequiredDates[timeCounter] - anchorDate.value; newFXfwd = fxSource.GetRate(new Date(anchorDate.value + dt)); dt = dt / 365.0; double sdt = Math.Sqrt(dt); double dW = normal.Generate(); // TODO: drift needs to be adjusted for default rate * jump size simRate = simRate * newFXfwd / oldFxFwd * Math.Exp((-0.5 * fxVol * fxVol) * dt + fxVol * sdt * dW); if (simDefaultTime < allRequiredDates[timeCounter]) { simulation[allRequiredDates[timeCounter]] = simRate * (1 + relJumpSizeInDefault); } else { simulation[allRequiredDates[timeCounter]] = simRate; } } }
public override double Next() { double eta = _unif.Generate(); return(eta < _sg1?_a.Next() : eta < _sg2?_b.Next() : _c.Next()); }
public void GenerateTest2() { UniformContinuousDistribution target = new UniformContinuousDistribution(0, 2); double[] samples = new double[1000000]; for (int i = 0; i < samples.Length; i++) { samples[i] = target.Generate(); Assert.IsTrue(samples[i] >= 0); Assert.IsTrue(samples[i] <= 2); } UniformContinuousDistribution newTarget = new UniformContinuousDistribution(); newTarget.Fit(samples); Assert.AreEqual(0, newTarget.Minimum, 1e-5); Assert.AreEqual(2, newTarget.Maximum, 1e-5); }
public void GenerateTest2() { UniformContinuousDistribution target = new UniformContinuousDistribution(-1, 4); double[] samples = new double[1000000]; for (int i = 0; i < samples.Length; i++) samples[i] = target.Generate(); var actual = UniformContinuousDistribution.Estimate(samples); actual.Fit(samples); Assert.AreEqual(-1, actual.Minimum, 1e-4); Assert.AreEqual(4, actual.Maximum, 1e-4); }
private double RndC1() { return(T.d_rev(_unif1.Generate())); }
private void radButton1_Click(object sender, EventArgs e) { // чистим данные Id.Clear(); X.Clear(); // чистим графики scatterplotView1.Graph.GraphPane.CurveList.Clear(); radChartView1.Series[0].DataPoints.Clear(); radChartView2.Series[0].DataPoints.Clear(); // параметиры для генерации выборки int N = this.labeledIntValue1.Value; double Xmin = this.doubleRange1.From; double Xmax = this.doubleRange1.To; // перепроверяем минумум-максимум if (Xmax < Xmin) { double tmp = Xmax; Xmax = Xmin; Xmin = tmp; doubleRange1.From = Xmin; doubleRange1.To = Xmax; } // генерируем индекс (можно быстрее, но так нагляднее) for (int i = 0; i < N; i++) { Id.Add(i); } // интервал для генератора случайных чисел Accord.DoubleRange range = new Accord.DoubleRange(Xmin, Xmax); // генератор UniformContinuousDistribution uniform = new UniformContinuousDistribution(range); // создание выборки объемом N X.AddRange(uniform.Generate(N)); // визуализация - скаттерплот scatterplotView1.DataSource = X.ToArray(); // визуализация - гистограмма Histogram histogram = new Histogram(); histogram.Compute(X.ToArray()); histogramView1.DataSource = histogram; for (int i = 0; i < N; i++) { radChartView1.Series[0].DataPoints.Add(new ScatterDataPoint(Id[i], X[i])); } foreach (HistogramBin bin in histogram.Bins) { string b = $"{bin.Range.Min}-{bin.Range.Max}"; radChartView2.Series[0].DataPoints.Add(new CategoricalDataPoint(bin.Value, b)); } }
public override double Next() { return(T.d_rev(_unif.Generate())); }
public override double Next() { return(_unif2.Generate() < 1 ? Rnd1() : Rnd2()); }
public override double Next() { double rnd = _unif.Generate(); return(rnd < T.Beta ? _a.Next() : (rnd > _p2 ? _c.Next() : _b.Next())); }
public static double runif(double a, double b) { return(a + _unif.Generate() * (b - a)); }