public static int DiscreteUniform(int min, int max, bool cache)
{
if (min == max)
{
return(min);
}
Debug.Assert(min < max);
DiscreteUniformDistribution uniform;
Pair <int, int> key = new Pair <int, int>(min, max);
if (!discreteUniformGenerators.ContainsKey(key))
{
uniform = new DiscreteUniformDistribution(generator);
// Beta must always be greater than Alpha, so we set them this way round
AlphaAndBeta(uniform, min, max);
if (cache)
{
discreteUniformGenerators.Add(key, uniform);
}
}
else
{
uniform = discreteUniformGenerators[key];
}
Debug.Assert(uniform != null);
Debug.Assert(uniform.Alpha == min);
Debug.Assert(uniform.Beta == max);
int value = uniform.Next();
Debug.Assert(value >= min && value <= max);
return(value);
}
static MatrixValue Generate(Int32 n, Int32 m)
{
var distribution = new DiscreteUniformDistribution(Rng);
var l = n * m;
var M = new MatrixValue(n, m);
var numbers = new List <Int32>();
distribution.Alpha = 0;
for (var i = 1; i <= l; i++)
{
numbers.Add(i);
}
for (var j = 1; j <= n; j++)
{
for (var i = 1; i <= m; i++)
{
distribution.Beta = numbers.Count - 1;
var index = distribution.Next();
index = Math.Max(Math.Min(0, index), numbers.Count - 1);
M[j, i] = new ScalarValue(numbers[index]);
numbers.RemoveAt(index);
}
}
return(M);
}
public void DiscreteUniformDistribution()
{
Simulation.NumberOfSamples = 5;
JsonSerializer serializer = JsonSerializer.Create(JsonSettings.SerializerSettings);
string name = "My Distribution";
var val = new DiscreteUniformDistribution(1, 5, 0)
{
Name = name
};
Guid guid = val.Guid;
string json = JObject.FromObject(val, serializer).ToString();
Simulation.ClearDistributionList();
var newVal = JObject.Parse(json).ToObject <DiscreteUniformDistribution>(serializer);
Assert.AreEqual(val.Guid, newVal.Guid);
Assert.AreEqual(val.ConstrainedToInt, newVal.ConstrainedToInt);
Assert.AreEqual(val.RandomSeed, newVal.RandomSeed);
Assert.AreEqual(val.Min.ScalarValue, newVal.Min.ScalarValue);
Assert.AreEqual(val.Minimum, newVal.Minimum);
Assert.AreEqual(val.Max.ScalarValue, 5);
Assert.AreEqual(val.Maximum, 5);
Assert.AreEqual(val.Mean, 3.4);
Assert.AreEqual(val.Name, name);
}
public void ImplicitOperatorExceptions()
{
bool exceptionCaught = false;
try
{
QrtValue val = null;
}
catch (ArgumentNullException)
{
exceptionCaught = true;
}
//Assert.IsTrue(exceptionCaught);
exceptionCaught = false;
try
{
QrtValue val = new DiscreteUniformDistribution(1.0, 5.0);
}
catch (ArgumentException)
{
exceptionCaught = true;
}
Assert.IsTrue(exceptionCaught);
}
public void DiscreteUniformDistribution_Result()
{
Simulation.NumberOfSamples = ExpectedResults.NumberOfSamples;
//var duhh = ExpectedResults.GetDistributionObject<BernoulliDistribution>();
var testInfo = ExpectedResults.Data["DistributionResults"]["DiscreteUniformDistribution"];
var inputs = testInfo["ConstructorInputs"];
var resultsArray = testInfo["Results"]
.Select(jv => (double)jv).ToArray();
DiscreteUniformDistribution distr = new DiscreteUniformDistribution(
inputs["min"].Value <int>(),
inputs["max"].Value <int>(),
inputs["randomSeed"].Value <int>());
Vector <double> expectedResults = Vector <double> .Build.DenseOfArray(resultsArray);
Assert.AreEqual(expectedResults, distr.GetResult());
distr = new DiscreteUniformDistribution(1, 200);
Assert.AreEqual(distr.Min.ScalarValue, 1);
Assert.AreEqual(distr.Max.ScalarValue, 200);
distr = new DiscreteUniformDistribution();
Assert.AreEqual(distr.Min.ScalarValue, 0);
Assert.AreEqual(distr.Max.ScalarValue, 0);
}
public void NaiveBayesConstructorTest4()
{
int classes = 2;
int inputCount = 3;
double[] priors = { 0.4, 0.6 };
DiscreteUniformDistribution initial = new DiscreteUniformDistribution(0, 3);
var target = new NaiveBayes <DiscreteUniformDistribution>(classes, inputCount, initial, priors);
Assert.AreEqual(classes, target.ClassCount);
Assert.AreEqual(inputCount, target.InputCount);
Assert.AreEqual(priors.Length, target.Priors.Length);
Assert.AreEqual(0.4, target.Priors[0]);
Assert.AreEqual(0.6, target.Priors[1]);
Assert.AreEqual(2, target.Distributions.GetLength(0));
Assert.AreEqual(3, target.Distributions.GetLength(1));
for (int i = 0; i < classes; i++)
{
for (int j = 0; j < inputCount; j++)
{
Assert.AreNotSame(initial, target.Distributions[i, j]);
Assert.AreEqual(0, target.Distributions[i, j].Minimum);
Assert.AreEqual(3, target.Distributions[i, j].Maximum);
}
}
}
public void DistributionQrtValue()
{
Simulation.NumberOfSamples = 5;
JsonSerializer serializer = JsonSerializer.Create(JsonSettings.SerializerSettings);
string name = "My Distribution";
var distr = new DiscreteUniformDistribution(1, 5, 0)
{
Name = name
};
QrtValue qrtValue = distr;
string distrJson = JObject.FromObject(distr, serializer).ToString();
string qrtJson = JObject.FromObject(qrtValue, serializer).ToString();
Simulation.ClearDistributionList();
var newDistr = JObject.Parse(distrJson).ToObject <DiscreteUniformDistribution>(serializer);
var newQrtValue = JObject.Parse(qrtJson).ToObject <QrtValue>(serializer);
Assert.AreEqual(distr.Guid, newQrtValue.DistributionValue.Guid);
Assert.AreEqual(distr.ConstrainedToInt, newQrtValue.DistributionValue.ConstrainedToInt);
Assert.AreEqual(distr.Minimum, newQrtValue.Minimum);
Assert.AreEqual(distr.Maximum, newQrtValue.Maximum);
Assert.AreEqual(distr.ConstrainedToInt, newQrtValue.ConstrainedToInt);
Assert.IsTrue(newQrtValue.IsDistribution);
}
// A routine to work around the mis-feature in setting alpha and beta
private static void AlphaAndBeta(DiscreteUniformDistribution distribution, int alpha, int beta)
{
distribution.Alpha = Math.Min(alpha, distribution.Alpha);
distribution.Beta = Math.Max(beta, distribution.Beta);
distribution.Alpha = alpha;
distribution.Beta = beta;
Debug.Assert(distribution.Alpha == alpha);
Debug.Assert(distribution.Beta == beta);
}
public void ImplicitOperatorDistributionInteger()
{
Simulation.NumberOfSamples = ExpectedResults.NumberOfSamples;
DiscreteUniformDistribution distr = new DiscreteUniformDistribution(1, 1000);
QrtValue qrtVal = distr;
Assert.IsTrue(qrtVal.IsDistribution);
Assert.IsTrue(qrtVal.ConstrainedToInt);
Assert.AreEqual(qrtVal.ScalarValue, 0);
Assert.AreEqual(qrtVal.DistributionValue.GetResult(), distr.GetResult());
}
static Rng()
{
// Create a commonly-used and quicly locatable zeroOrOne distribution,
// and also reference it in the discreteUniformGeneratirs dictionary
zeroOrOne = new DiscreteUniformDistribution(generator);
AlphaAndBeta(zeroOrOne, 0, 1);
discreteUniformGenerators.Add(new Pair <int, int>(0, 1), zeroOrOne);
// Create a commonly-used and quickly locatable zeroToOne distribution,
// and also reference it in the continuousUniformGenerators dictionary
zeroToOne = new ContinuousUniformDistribution(generator);
AlphaAndBeta(zeroToOne, 0.0, 1.0);
continuousUniformGenerators.Add(new Pair <double, double>(0.0, 1.0), zeroToOne);
}
public ValueType Sample()
{
var uniformDistribution = new DiscreteUniformDistribution(100); //[0, maxValue)
var randValue = uniformDistribution.Sample(rand) + 1;
if (randValue >= 0 && randValue <= _accumulateOutcome1)
{
return(EventEnum.ScaningSmallAmountItems);
}
else if (randValue > _accumulateOutcome1 && randValue <= _accumulateOutcome2)
{
return(EventEnum.ScaningMediumAmountItems);
}
return(EventEnum.ScaningLargeAmountItems);
}
public Form1()
{
InitializeComponent();
//--
mTranslations = new Dictionary <string, Translations>();
mPlainListWords = new PlainWords();
//--
mBinominalDistr = new BinomialDistribution();
mTriangleDistr = new TriangularDistribution();
mUniformDistr = new DiscreteUniformDistribution();
mContUniformDist = new ContinuousUniformDistribution();
mRnd = new Random();
mStopTimer = false;
}
public void TestDiscreteUniformDistribution()
{
double[][] para =
{
new double[] { 1, 11, 5, 0.4545454545454545454545455, 0.09090909090909090909090909 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new DiscDistTester(para[i], delegate(double a, double b)
{
var ret = new DiscreteUniformDistribution((int)a, (int)b);
return(ret);
}
);
tester.Test(1E-14);
}
}
public static Chromosome Cross(Tuple <Chromosome, Chromosome> pair, Random random)
{
IList <double> values;
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
DiscreteUniformDistribution discrete = new DiscreteUniformDistribution(0, 1);
double randomNumber = uniform.GetRandomValue(random);
if (randomNumber <= SELECTION_1_PROBABILITY) // whole arithmetic recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => (x + y) / 2).ToList();
}
else if (randomNumber <= SELECTION_1_PROBABILITY + SELECTION_2_PROBABILITY) // discrete recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => discrete.GetRandomValue(random) == 0 ? x : y).ToList();
}
else // simple arithmetic recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => pair.Item1.Values.IndexOf(x) < pair.Item1.Values.Count / 2 ? x : (x + y) / 2).ToList();
}
return(new Chromosome(values));
}
public static Tuple <Chromosome, Chromosome> Select(IList <Chromosome> population, Random random, out Chromosome worst)
{
SortedSet <Chromosome> tournament = new SortedSet <Chromosome>();
DiscreteUniformDistribution discrete = new DiscreteUniformDistribution(0, population.Count - 1);
while (tournament.Count < K)
{
int index = discrete.GetRandomValue(random);
tournament.Add(population[index]);
}
worst = tournament.Max;
tournament.Remove(worst);
double sumFitness;
CalculateFitness(tournament, out sumFitness);
Chromosome parent1 = SelectParent(tournament, sumFitness, random);
tournament.Remove(parent1);
CalculateFitness(tournament, out sumFitness);
Chromosome parent2 = SelectParent(tournament, sumFitness, random);
return(new Tuple <Chromosome, Chromosome>(parent1, parent2));
}
/// <summary>
/// Sets the distribution for operations using the current genrator
/// </summary>
/// <param name="distx">Distx.</param>
public void setDistribution(distributions distx, Dictionary <string, double> args)
{
//TODO check arguments to ensure they are making a change to the distribution
//otherwise throw an exception see laplace as a example of implementing this
switch (distx)
{
case distributions.Bernoili:
BernoulliDistribution x0 = new BernoulliDistribution(gen);
if (args.ContainsKey("alpha"))
{
x0.Alpha = args["alpha"];
}
else
{
throw new System.Exception("for Bernoili distribution you must provide an alpha");
}
dist = x0;
break;
case distributions.Beta:
BetaDistribution x1 = new BetaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x1.Alpha = args["alpha"];
x1.Beta = args["beta"];
}
else
{
throw new System.Exception(" for beta distribution you must provide alpha and beta");
}
dist = x1;
break;
case distributions.BetaPrime:
BetaPrimeDistribution x2 = new BetaPrimeDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x2.Alpha = args["alpha"];
x2.Beta = args["beta"];
}
else
{
throw new System.Exception(" for betaPrime distribution you must provide alpha and beta");
}
dist = x2;
break;
case distributions.Cauchy:
CauchyDistribution x3 = new CauchyDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("gamma"))
{
x3.Alpha = args["alpha"];
x3.Gamma = args["gamma"];
}
else
{
throw new System.Exception("for cauchy dist you must provide alpha and gamma");
}
dist = x3;
break;
case distributions.Chi:
ChiDistribution x4 = new ChiDistribution(gen);
if (args.ContainsKey("alpha"))
{
x4.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chi you must provide alpha");
}
dist = x4;
break;
case distributions.ChiSquared:
ChiSquareDistribution x5 = new ChiSquareDistribution(gen);
if (args.ContainsKey("alpha"))
{
x5.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chiSquared you must provide alpha");
}
dist = x5;
break;
case distributions.ContinuousUniform:
ContinuousUniformDistribution x6 = new ContinuousUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x6.Alpha = args["alpha"];
x6.Beta = args["beta"];
}
else
{
throw new System.Exception("for ContinuousUniform you must provide alpha and beta");
}
dist = x6;
break;
case distributions.DiscreteUniform:
DiscreteUniformDistribution x7 = new DiscreteUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x7.Alpha = (int)args["alpha"];
x7.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for discrete uniform distribution you must provide alpha and beta");
}
dist = x7;
break;
case distributions.Erlang:
ErlangDistribution x8 = new ErlangDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x8.Alpha = (int)args["alpha"];
x8.Lambda = (int)args["lambda"];
}
else
{
throw new System.Exception("for Erlang dist you must provide alpha and lambda");
}
dist = x8;
break;
case distributions.Exponential:
ExponentialDistribution x9 = new ExponentialDistribution(gen);
if (args.ContainsKey("lambda"))
{
x9.Lambda = args["lambda"];
}
else
{
throw new System.Exception("for exponential dist you must provide lambda");
}
dist = x9;
break;
case distributions.FisherSnedecor:
FisherSnedecorDistribution x10 = new FisherSnedecorDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x10.Alpha = (int)args["alpha"];
x10.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for FisherSnedecor you must provide alpha and beta");
}
dist = x10;
break;
case distributions.FisherTippett:
FisherTippettDistribution x11 = new FisherTippettDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
x11.Alpha = args["alpha"];
x11.Mu = args["mu"];
}
else
{
throw new System.Exception("for FisherTippets you must provide alpha and mu");
}
dist = x11;
break;
case distributions.Gamma:
GammaDistribution x12 = new GammaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("theta"))
{
x12.Alpha = args["alpha"];
x12.Theta = args["theta"];
}
else
{
throw new System.Exception("for Gamma dist you must provide alpha and theta");
}
dist = x12;
break;
case distributions.Geometric:
GeometricDistribution x13 = new GeometricDistribution(gen);
if (args.ContainsKey("alpha"))
{
x13.Alpha = args["alpha"];
}
else
{
throw new System.Exception("Geometric distribution requires alpha value");
}
dist = x13;
break;
case distributions.Binomial:
BinomialDistribution x14 = new BinomialDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x14.Alpha = args["alpha"];
x14.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("binomial distribution requires alpha and beta");
}
dist = x14;
break;
case distributions.None:
break;
case distributions.Laplace:
LaplaceDistribution x15 = new LaplaceDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
if (x15.IsValidAlpha(args["alpha"]) && x15.IsValidMu(args["mu"]))
{
x15.Alpha = args["alpha"];
x15.Mu = args["mu"];
}
else
{
throw new ArgumentException("alpha must be greater than zero");
}
}
else
{
throw new System.Exception("Laplace dist requires alpha and mu");
}
dist = x15;
break;
case distributions.LogNormal:
LognormalDistribution x16 = new LognormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x16.Mu = args["mu"];
x16.Sigma = args["sigma"];
}
else
{
throw new System.Exception("lognormal distribution requires mu and sigma");
}
dist = x16;
break;
case distributions.Normal:
NormalDistribution x17 = new NormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x17.Mu = args["mu"];
x17.Sigma = args["sigma"];
}
else
{
throw new System.Exception("normal distribution requires mu and sigma");
}
dist = x17;
break;
case distributions.Pareto:
ParetoDistribution x18 = new ParetoDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x18.Alpha = args["alpha"];
x18.Beta = args["beta"];
}
else
{
throw new System.Exception("pareto distribution requires alpha and beta");
}
dist = x18;
break;
case distributions.Poisson:
PoissonDistribution x19 = new PoissonDistribution(gen);
if (args.ContainsKey("lambda"))
{
x19.Lambda = args["lambda"];
}
else
{
throw new System.Exception("Poisson distribution requires lambda");
}
dist = x19;
break;
case distributions.Power:
PowerDistribution x20 = new PowerDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x20.Alpha = args["alpha"];
x20.Beta = args["beta"];
}
else
{
throw new System.Exception("Power dist requires alpha and beta");
}
dist = x20;
break;
case distributions.RayLeigh:
RayleighDistribution x21 = new RayleighDistribution(gen);
if (args.ContainsKey("sigma"))
{
x21.Sigma = args["sigma"];
}
else
{
throw new System.Exception("Rayleigh dist requires sigma");
}
dist = x21;
break;
case distributions.StudentsT:
StudentsTDistribution x22 = new StudentsTDistribution(gen);
if (args.ContainsKey("nu"))
{
x22.Nu = (int)args["nu"];
}
else
{
throw new System.Exception("StudentsT dist requirres nu");
}
dist = x22;
break;
case distributions.Triangular:
TriangularDistribution x23 = new TriangularDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta") && args.ContainsKey("gamma"))
{
x23.Alpha = args["alpha"];
x23.Beta = args["beta"];
x23.Gamma = args["gamma"];
}
else
{
throw new System.Exception("Triangular distribution requires alpha, beta and gamma");
}
dist = x23;
break;
case distributions.WeiBull:
WeibullDistribution x24 = new WeibullDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x24.Alpha = args["alpha"];
x24.Lambda = args["lambda"];
}
else
{
throw new System.Exception("WeiBull dist requires alpha and lambda");
}
dist = x24;
break;
default:
throw new NotImplementedException("the distribution you want has not yet been implemented " +
"you could help everyone out by going and implementing it");
}
}
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f, ArgumentsValue P)
{
var numberOfBootstrapSamples = n.GetIntegerOrThrowException("n", Name);
var nConfigs = cfgs.DimensionY;
var nData = cfgs.DimensionX;
var distribution = new DiscreteUniformDistribution(Rng)
{
Beta = nConfigs,
Alpha = 1
};
if (numberOfBootstrapSamples <= 1)
throw new YAMPException("Bootstrap: The number of bootstrap samples n is smaller or equal to 1!");
var parameters = new ArgumentsValue(cfgs);
foreach (var m in P.Values)
{
parameters.Insert(m);
}
var temp = f.Perform(Context, parameters);
var nResult = 0;//dimension of the result
if (temp is ScalarValue)
{
nResult = 1;
}
else if (temp is MatrixValue)
{
nResult = ((MatrixValue)temp).Length;
}
else
{
throw new YAMPException("Bootstrap: The observable f has to return either a scalar or a matrix!");
}
var BootstrapObservable = new MatrixValue(numberOfBootstrapSamples, nResult);
for (var i = 1; i <= numberOfBootstrapSamples; i++)
{
var BootstrapConfigs = new MatrixValue(nConfigs, nData);
for (var j = 1; j <= nConfigs; j++)
{
var idx = distribution.Next();
for (var k = 1; k <= nData; k++)
{
BootstrapConfigs[j, k] = cfgs[idx, k];
}
}
parameters = new ArgumentsValue(BootstrapConfigs);
foreach (var m in P.Values)
{
parameters.Insert(m);
}
temp = f.Perform(Context, parameters);
if (temp is ScalarValue)
{
BootstrapObservable[i] = (ScalarValue)temp;
}
else
{
var m = (MatrixValue)temp;
for (var k = 1; k <= nResult; k++)
{
BootstrapObservable[i, k] = m[k];
}
}
}
temp = YMath.Average(BootstrapObservable);
for (var i = 1; i <= numberOfBootstrapSamples; i++)
{
if (temp is ScalarValue)
{
BootstrapObservable[i] -= temp as ScalarValue;
BootstrapObservable[i] *= BootstrapObservable[i];
}
else
{
var T = temp as MatrixValue;
for (var k = 1; k <= nResult; k++)
{
BootstrapObservable[i, k] -= T[k];
BootstrapObservable[i, k] *= BootstrapObservable[i, k];
}
}
}
var error = YMath.Average(BootstrapObservable);
var sqrt = new SqrtFunction();
error = sqrt.Perform(error);
var result = new MatrixValue(2, nResult);
if (temp is ScalarValue)
{
result[1] = (ScalarValue)temp;
result[2] = (ScalarValue)error;
}
else
{
var T = (MatrixValue)temp;
var E = (MatrixValue)error;
for (var k = 1; k <= nResult; k++)
{
result[1, k] = T[k];
result[2, k] = E[k];
}
}
return result;
}
/// <summary>
/// Constructor que recibe los parámetros de inicialización del ambiente
/// </summary>
/// <param name="rows"> Número de filas </param>
/// <param name="cols"> Número de columnas </param>
/// <param name="t"> Número de turnos que transcurren entre un cambio del ambiente y el próximo </param>
/// <param name="dirtPercent"> Porciento de celdas sucias </param>
/// <param name="obstaclePercent"> Porciento de obstáculos </param>
/// <param name="childrenCount"> Número de niños </param>
public Environment(int rows, int cols, int t, double dirtPercent, double obstaclePercent, int childrenCount, Type robotType)
{
randomDirt = new DiscreteUniformDistribution(0, 6);
randomMov = new DiscreteUniformDistribution(0, 3);
randomGrid = new DiscreteUniformDistribution(0, 7);
//Si dirtPercent >= 60% generar una excepción porque el ambiente inicial no sería factible
if (dirtPercent >= dirtTop)
{
throw new Exception("Los parámetros de inicialización no permiten crear un ambiente factible.");
}
Dimensions = new Point(rows, cols);
//Crear las cuadrículas del ambiente
cells = new Cell[rows, cols];
for (var i = 0; i < rows; i++)
{
for (var j = 0; j < cols; j++)
{
cells[i, j] = new Cell(new Point(i, j));
}
}
randomXPos = new DiscreteUniformDistribution(0, rows - 1);
randomYPos = new DiscreteUniformDistribution(0, cols - 1);
TurnsToChange = t;
envChanges = 1;
ChildrenCount = childrenCount;
//Crear el corral
CreatePlaypen();
ObstaclePercent = obstaclePercent;
//Calcular el número de obstáculos a partir del %. Se escoge el entero <= que el valor
obstacleCount = (int)Math.Floor(obstaclePercent * (Length - playpen.Length) / 100);
//Calcular el número de casillas vacías
EmptyCount = Length - obstacleCount - playpen.Length;
//Guardar el % inicial de suciedad por si se necesita para las estadísticas
initialDirtPercent = dirtPercent;
//Calcular el número de casillas sucias a partir del % y el número de casillas vacías.
//Se escoge el entero <= que el valor
initialDirtCount = (int)Math.Floor(dirtPercent * EmptyCount / 100);
int cleanCount = EmptyCount - initialDirtCount;
//La cantidad de casillas limpias debe permitir ubicar a los niños y poder hacer al menos un movimiento
if (cleanCount - childrenCount <= 0)
{
throw new Exception("Los parámetros de inicialización no permiten crear un ambiente factible.");
}
//Generar los obstáculos
GenerateInitialObstacles(obstacleCount);
//Generar la suciedad inicial a partir del parámetro
GenerateInitialDirt(initialDirtCount);
DirtCount = initialDirtCount;
CleanCount = 0;
//Generar posiciones aleatorias para los niños
CreateChildren();
var ctor = robotType.GetConstructor(new[] { typeof(Environment) });
var robot = (HomeRobot)ctor.Invoke(new[] { this });
//Generar aleatoriamente la posición del robot en una casilla vacía dentro de los límites del ambiente\
SetRobot(robot);
}
public virtual void Reset(Point pos)
{
randomMov = new DiscreteUniformDistribution(0, 4);
CurrentPos = pos;
PreviousPos = new Point();
}
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f, ArgumentsValue P)
{
var numberOfBootstrapSamples = n.GetIntegerOrThrowException("n", Name);
var nConfigs = cfgs.DimensionY;
var nData = cfgs.DimensionX;
var distribution = new DiscreteUniformDistribution(Rng)
{
Beta = nConfigs,
Alpha = 1
};
if (numberOfBootstrapSamples <= 1)
{
throw new YAMPException("Bootstrap: The number of bootstrap samples n is smaller or equal to 1!");
}
var parameters = new ArgumentsValue(cfgs);
foreach (var m in P.Values)
{
parameters.Insert(m);
}
var temp = f.Perform(Context, parameters);
var nResult = 0;//dimension of the result
if (temp is ScalarValue)
{
nResult = 1;
}
else if (temp is MatrixValue)
{
nResult = ((MatrixValue)temp).Length;
}
else
{
throw new YAMPException("Bootstrap: The observable f has to return either a scalar or a matrix!");
}
var BootstrapObservable = new MatrixValue(numberOfBootstrapSamples, nResult);
for (var i = 1; i <= numberOfBootstrapSamples; i++)
{
var BootstrapConfigs = new MatrixValue(nConfigs, nData);
for (var j = 1; j <= nConfigs; j++)
{
var idx = distribution.Next();
for (var k = 1; k <= nData; k++)
{
BootstrapConfigs[j, k] = cfgs[idx, k];
}
}
parameters = new ArgumentsValue(BootstrapConfigs);
foreach (var m in P.Values)
{
parameters.Insert(m);
}
temp = f.Perform(Context, parameters);
if (temp is ScalarValue)
{
BootstrapObservable[i] = (ScalarValue)temp;
}
else
{
var m = (MatrixValue)temp;
for (var k = 1; k <= nResult; k++)
{
BootstrapObservable[i, k] = m[k];
}
}
}
temp = YMath.Average(BootstrapObservable);
for (var i = 1; i <= numberOfBootstrapSamples; i++)
{
if (temp is ScalarValue)
{
BootstrapObservable[i] -= temp as ScalarValue;
BootstrapObservable[i] *= BootstrapObservable[i];
}
else
{
var T = temp as MatrixValue;
for (var k = 1; k <= nResult; k++)
{
BootstrapObservable[i, k] -= T[k];
BootstrapObservable[i, k] *= BootstrapObservable[i, k];
}
}
}
var error = YMath.Average(BootstrapObservable);
var sqrt = new SqrtFunction();
error = sqrt.Perform(error);
var result = new MatrixValue(2, nResult);
if (temp is ScalarValue)
{
result[1] = (ScalarValue)temp;
result[2] = (ScalarValue)error;
}
else
{
var T = (MatrixValue)temp;
var E = (MatrixValue)error;
for (var k = 1; k <= nResult; k++)
{
result[1, k] = T[k];
result[2, k] = E[k];
}
}
return(result);
}
