private void initialize()
{
// firstSeed is chosen based on clock() and used for the first rng
ulong firstSeed = (ulong)DateTime.Now.Ticks;
MersenneTwisterUniformRng first = new MersenneTwisterUniformRng(firstSeed);
// secondSeed is as random as it could be
// feel free to suggest improvements
ulong secondSeed = first.nextInt32();
MersenneTwisterUniformRng second = new MersenneTwisterUniformRng(secondSeed);
// use the second rng to initialize the final one
ulong skip = second.nextInt32() % 1000;
List <ulong> init = new InitializedList <ulong>(4);
init[0] = second.nextInt32();
init[1] = second.nextInt32();
init[2] = second.nextInt32();
init[3] = second.nextInt32();
rng_ = new MersenneTwisterUniformRng(init);
for (ulong i = 0; i < skip; i++)
{
rng_.nextInt32();
}
}
public static List <Func <Vector, double> > multiPathBasisSystem(int dim, int order, PolynomType polynomType)
{
List <Func <double, double> > b = pathBasisSystem(order, polynomType);
List <Func <Vector, double> > ret = new List <Func <Vector, double> >();
ret.Add((xx) => 1.0);
for (int i = 1; i <= order; ++i)
{
List <Func <Vector, double> > a = w(dim, i, polynomType, b);
foreach (var iter in a)
{
ret.Add(iter);
}
}
// remove-o-zap: now remove redundant functions.
// usually we do have a lot of them due to the construction schema.
// We use a more "hands on" method here.
List <bool> rm = new InitializedList <bool>(ret.Count, true);
Vector x = new Vector(dim), v = new Vector(ret.Count);
MersenneTwisterUniformRng rng = new MersenneTwisterUniformRng(1234UL);
for (int i = 0; i < 10; ++i)
{
int k;
// calculate random x vector
for (k = 0; k < dim; ++k)
{
x[k] = rng.next().value;
}
// get return values for all basis functions
for (k = 0; k < ret.Count; ++k)
{
v[k] = ret[k](x);
}
// find duplicates
for (k = 0; k < ret.Count; ++k)
{
if (v.First(xx => (Math.Abs(v[k] - xx) <= 10 * v[k] * Const.QL_EPSILON)).IsEqual(v.First() + k))
{
// don't remove this item, it's unique!
rm[k] = false;
}
}
}
int iter2 = 0;
for (int i = 0; i < rm.Count; ++i)
{
if (rm[i])
{
ret.RemoveAt(iter2);
}
else
{
++iter2;
}
}
return(ret);
}
public DifferentialEvolution(Configuration configuration = null)
{
configuration_ = configuration ?? new Configuration();
rng_ = new MersenneTwisterUniformRng(configuration_.seed);
}
public SobolRsg(int dimensionality, ulong seed, DirectionIntegers directionIntegers)
{
dimensionality_ = dimensionality;
sequenceCounter_ = 0;
firstDraw_ = true;
sequence_ = new Sample <List <double> >(new InitializedList <double>(dimensionality), 1.0);
integerSequence_ = new InitializedList <ulong>(dimensionality);
directionIntegers_ = new InitializedList <List <ulong> >(dimensionality);
for (int i = 0; i < dimensionality; i++)
{
directionIntegers_[i] = new InitializedList <ulong>(bits_);
}
Utils.QL_REQUIRE(dimensionality > 0, () => "dimensionality must be greater than 0");
Utils.QL_REQUIRE(dimensionality <= PPMT_MAX_DIM, () =>
"dimensionality " + dimensionality + " exceeds the number of available " +
"primitive polynomials modulo two (" + PPMT_MAX_DIM + ")");
// initializes coefficient array of the k-th primitive polynomial
// and degree of the k-th primitive polynomial
List <uint> degree = new InitializedList <uint>(dimensionality_);
List <long> ppmt = new InitializedList <long>(dimensionality_);
bool useAltPolynomials = false;
if (directionIntegers == DirectionIntegers.Kuo || directionIntegers == DirectionIntegers.Kuo2 ||
directionIntegers == DirectionIntegers.Kuo3 || directionIntegers == DirectionIntegers.SobolLevitan ||
directionIntegers == DirectionIntegers.SobolLevitanLemieux)
{
useAltPolynomials = true;
}
// degree 0 is not used
ppmt[0] = 0;
degree[0] = 0;
int k, index;
uint currentDegree = 1;
k = 1;
index = 0;
uint altDegree = useAltPolynomials ? maxAltDegree : 0;
for (; k < Math.Min(dimensionality_, altDegree); k++, index++)
{
ppmt[k] = AltPrimitivePolynomials[currentDegree - 1][index];
if (ppmt[k] == -1)
{
++currentDegree;
index = 0;
ppmt[k] = AltPrimitivePolynomials[currentDegree - 1][index];
}
degree[k] = currentDegree;
}
for (; k < dimensionality_; k++, index++)
{
ppmt[k] = PrimitivePolynomials[currentDegree - 1][index];
if (ppmt[k] == -1)
{
++currentDegree;
index = 0;
ppmt[k] = PrimitivePolynomials[currentDegree - 1][index];
}
degree[k] = currentDegree;
}
// initializes bits_ direction integers for each dimension
// and store them into directionIntegers_[dimensionality_][bits_]
//
// In each dimension k with its associated primitive polynomial,
// the first degree_[k] direction integers can be chosen freely
// provided that only the l leftmost bits can be non-zero, and
// that the l-th leftmost bit must be set
// degenerate (no free direction integers) first dimension
int j;
for (j = 0; j < bits_; j++)
{
directionIntegers_[0][j] = (1UL << (bits_ - j - 1));
}
int maxTabulated = 0;
// dimensions from 2 (k=1) to maxTabulated (k=maxTabulated-1) included
// are initialized from tabulated coefficients
switch (directionIntegers)
{
case DirectionIntegers.Unit:
maxTabulated = dimensionality_;
for (k = 1; k < maxTabulated; k++)
{
for (int l = 1; l <= degree[k]; l++)
{
directionIntegers_[k][l - 1] = 1UL;
directionIntegers_[k][l - 1] <<= (bits_ - l);
}
}
break;
case DirectionIntegers.Jaeckel:
// maxTabulated=32
maxTabulated = initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.SobolLevitan:
// maxTabulated=40
maxTabulated = SLinitializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (SLinitializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = SLinitializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.SobolLevitanLemieux:
// maxTabulated=360
maxTabulated = Linitializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (Linitializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = Linitializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.JoeKuoD5:
// maxTabulated=1898
maxTabulated = JoeKuoD5initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (JoeKuoD5initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = JoeKuoD5initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.JoeKuoD6:
// maxTabulated=1799
maxTabulated = JoeKuoD6initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (JoeKuoD6initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = JoeKuoD6initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.JoeKuoD7:
// maxTabulated=1898
maxTabulated = JoeKuoD7initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (JoeKuoD7initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = JoeKuoD7initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.Kuo:
// maxTabulated=4925
maxTabulated = Kuoinitializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (Kuoinitializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = Kuoinitializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.Kuo2:
// maxTabulated=3946
maxTabulated = Kuo2initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (Kuo2initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = Kuo2initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
case DirectionIntegers.Kuo3:
// maxTabulated=4585
maxTabulated = Kuo3initializers.Length + 1;
for (k = 1; k < Math.Min(dimensionality_, maxTabulated); k++)
{
j = 0;
// 0UL marks coefficients' end for a given dimension
while (Kuo3initializers[k - 1][j] != 0UL)
{
directionIntegers_[k][j] = Kuo3initializers[k - 1][j];
directionIntegers_[k][j] <<= (bits_ - j - 1);
j++;
}
}
break;
default:
break;
}
// random initialization for higher dimensions
if (dimensionality_ > maxTabulated)
{
MersenneTwisterUniformRng uniformRng = new MersenneTwisterUniformRng(seed);
for (k = maxTabulated; k < dimensionality_; k++)
{
for (int l = 1; l <= degree[k]; l++)
{
do
{
// u is in (0,1)
double u = uniformRng.next().value;
// the direction integer has at most the
// rightmost l bits non-zero
directionIntegers_[k][l - 1] = (ulong)(u * (1UL << l));
}while ((directionIntegers_[k][l - 1] & 1UL) == 0);
// iterate until the direction integer is odd
// that is it has the rightmost bit set
// shifting bits_-l bits to the left
// we are guaranteed that the l-th leftmost bit
// is set, and only the first l leftmost bit
// can be non-zero
directionIntegers_[k][l - 1] <<= (bits_ - l);
}
}
}
// computation of directionIntegers_[k][l] for l>=degree_[k]
// by recurrence relation
for (k = 1; k < dimensionality_; k++)
{
uint gk = degree[k];
for (int l = (int)gk; l < bits_; l++)
{
// eq. 8.19 "Monte Carlo Methods in Finance" by P. Jдckel
ulong n = (directionIntegers_[k][(int)(l - gk)] >> (int)gk);
// a[k][j] are the coefficients of the monomials in ppmt[k]
// The highest order coefficient a[k][0] is not actually
// used in the recurrence relation, and the lowest order
// coefficient a[k][gk] is always set: this is the reason
// why the highest and lowest coefficient of
// the polynomial ppmt[k] are not included in its encoding,
// provided that its degree is known.
// That is: a[k][j] = ppmt[k] >> (gk-j-1)
for (uint z = 1; z < gk; z++)
{
// XORed with a selection of (unshifted) direction
// integers controlled by which of the a[k][j] are set
if ((((ulong)ppmt[k] >> (int)(gk - z - 1)) & 1UL) != 0)
{
n ^= directionIntegers_[k][(int)(l - z)];
}
}
// a[k][gk] is always set, so directionIntegers_[k][l-gk]
// will always enter
n ^= directionIntegers_[k][(int)(l - gk)];
directionIntegers_[k][l] = n;
}
}
// initialize the Sobol integer/double vectors
// first draw
for (k = 0; k < dimensionality_; k++)
{
integerSequence_[k] = directionIntegers_[k][0];
}
}
private SeedGenerator()
{
rng_ = new MersenneTwisterUniformRng(42UL);
initialize();
}
