/// <summary>
/// Crea el corral
/// </summary>
private void CreatePlaypen()
{
//Crear el corral que tenga una casilla para cada niño.
playpen = new Point[ChildrenCount];
//Las casillas deben ser adyacentes
//Generar aleatoriamente la primera casilla del corral
Point pos = RandomPos();
var i = 0;
playpen[i] = pos;
this[pos].CurrentStatus = CellStatus.Empty;
this[pos].PlaypenIndex = i++; //Guarda la posición de la casilla en el corral
//Generar el resto de las casillas del corral
while (i < ChildrenCount)
{
//Obtener los lados libre de la casilla
var adjacents = AdjacentCells(pos, p => !this[p].IsPlaypen());
//Decidir aleatoriamentes hacia cuál de los lados libres se va a crear la nueva casilla del corral
if (adjacents.Count > 0)
{
var n = randomMov.Next() % adjacents.Count;
pos = adjacents.ToArray <Tuple <MovementDirection, Point> >()[n].Item2;
}
else
{
var j = i - 2;
while (adjacents.Count == 0 && j >= 0)
{
pos = playpen[j--];
adjacents = AdjacentCells(pos, p => !this[p].IsPlaypen());
}
if (adjacents.Count > 0)
{
var n = randomMov.Next() % adjacents.Count;
pos = adjacents.ToArray <Tuple <MovementDirection, Point> >()[n].Item2;
}
}
//Adicionar la casilla al corral
playpen[i] = pos; //La próxima casilla se genera a partir de ésta
this[pos].CurrentStatus = CellStatus.Empty;
this[pos].PlaypenIndex = i++; //Guarda la posición de la casilla en el corral
}
}
public static int DiscreteUniformZeroOrOne()
{
int value = zeroOrOne.Next();
Debug.Assert(value == 0 || value == 1);
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);
}
protected virtual bool RandomMove(HashSet <Tuple <MovementDirection, Point> > adjacents, Func <Point, bool> precondition = null)
{
if (adjacents.Count > 0)
{
//Utilizar un generador para cada tipo de objeto
var n = randomMov.Next() % adjacents.Count;
var oper = adjacents.ToArray <Tuple <MovementDirection, Point> >()[n];
return(MoveTo(oper.Item2, precondition));
}
else
{
return(false);
}
}
/// <summary>
/// Genera entre 0 y maxCount casillas sucias en la cuadrícula
/// </summary>
/// <param name="maxCount"> Máximo número de casillas sucias a generar </param>
/// <param name="grid"> Cuadrícula donde se va a generar la suciedad </param>
/// <returns> Número de casillas sucias generadas </returns>
public int GenDirt(int maxCount, List <Point> grid)
{
if ((maxCount == 0) || (grid.Count == 0))
{
return(0);
}
var result = 0;
var count = randomDirt.Next() % (maxCount + 1);
while (result < count)
{
var p = grid[randomGrid.Next() % grid.Count];
this[p].Dirty();
dirtyCells.Add(p);
grid.Remove(p);
result++;
}
DirtCount += result;
return(result);
}
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);
}
public ScalarValue Function(ScalarValue min, ScalarValue max)
{
ran.Alpha = min.GetIntegerOrThrowException("min", Name);
ran.Beta = max.GetIntegerOrThrowException("max", Name);
return(new ScalarValue(ran.Next()));
}
//Genera aleatoriamente una casilla para situar algún elemento del ambiente
private Point RandomPos()
{
return(new Point(randomXPos.Next(), randomYPos.Next()));
//return new Point(n / Dimensions.Y, n % Dimensions.Y);
//return new Point(randomObj.RandomNumber(0, Dimensions.X), randomObj.RandomNumber(0, Dimensions.Y));
}
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;
}