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);
}
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);
}
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));
}
