/// <summary>
/// First method for determination of position of the debris.
/// </summary>
/// <param name="Splinter"> </param>
/// <param name="CountOfDimension"></param>
/// <param name="Amplitude"> </param>
/// <param name="LowerBounds"> </param>
/// <param name="UpperBounds"> </param>
protected void FirstMethodDeterminationOfPosition(Agent Splinter, int CountOfDimension, double Amplitude, IReadOnlyList <double> LowerBounds, IReadOnlyList <double> UpperBounds)
{
// The indices are choosing randomly.
GenerateIndicesOfAxes(CountOfDimension);
double h = 0;
// Calculate position of debris.
for (int i = 0; i < CountOfDimension; i++)
{
int axisIndex = _coordNumbers[i];
h = Amplitude * _uniformRand.URandVal(-1, 1);
Splinter.Point[axisIndex] += h;
if (Splinter.Point[axisIndex] < LowerBounds[axisIndex])
{
Splinter.Point[axisIndex] = _uniformRand.URandVal(LowerBounds[axisIndex], 0.5 * (LowerBounds[axisIndex] + UpperBounds[axisIndex]));
}
else if (Splinter.Point[axisIndex] > UpperBounds[axisIndex])
{
//Splinter.Point[axisIndex] = _uniformRand.URandVal(0.5 * (LowerBounds[axisIndex] + UpperBounds[axisIndex]), UpperBounds[axisIndex]);
Splinter.Point[axisIndex] = UpperBounds[axisIndex];
}
}
}
/// <summary>
/// If <paramref name="Value"/> out of range [ <paramref name="MinValue"/>;
/// <paramref name="MaxValue"/>], then clipping to a random value in the range.
/// </summary>
/// <param name="Value"> </param>
/// <param name="MinValue"> A minimum value of the range. </param>
/// <param name="MaxValue"> A maximum value of the range. </param>
/// <param name="UniformGen"> A random generator. </param>
/// <returns>
/// <para>
/// A random value in the range [ <paramref name="MinValue"/>; <paramref name="MaxValue"/>]
/// if <paramref name="Value"/> greater than <paramref name="MaxValue"/> or less than <paramref name="MinValue"/>.
/// </para>
/// <para> Otherwise <paramref name="Value"/>. </para>
/// </returns>
public static double RandomClamp(double Value, double MinValue, double MaxValue, IContUniformGen UniformGen)
{
if (Value < MinValue || Value > MaxValue)
{
return(UniformGen.URandVal(MinValue, MaxValue));
}
else
{
return(Value);
}
}
/// <summary>
/// </summary>
/// <param name="DimObjs"> </param>
private void InitAgents(IOOOptProblem Problem, int DimObjs)
{
int dimension = Problem.LowerBounds.Count;
for (int i = 0; i < _parameters.NP; i++)
{
PointND point = new PointND(0.0, dimension);
for (int j = 0; j < dimension; j++)
{
point[j] = _uniformRand.URandVal(Problem.LowerBounds[j], Problem.UpperBounds[j]);
}
_agents.Add(new Agent(point, new PointND(0.0, DimObjs)));
}
}
private void GenerateShrapnelesForGrenade(int WhichGrenade, int Dimension)
{
double p = Math.Max(1.0 / Dimension,
Math.Log10(_radiusGrenade / _radiusExplosion) / Math.Log10(_parameters.Pts));
if (CheckDouble.GetTypeValue(p) != DoubleTypeValue.Valid)
{
p = 0.5;
}
double randomValue1, randomValue2;
bool isShrapnelAdd = true;
PointND tempPoint = null;
// Generating shrapnels.
for (int i = 0; i < _parameters.NShrapnel; i++)
{
// Reuse an allocated memory, if 'tempPoint' was not added to the array, otherwise
// allocate a new memory.
if (isShrapnelAdd)
{
tempPoint = new PointND(0.0, Dimension);
}
randomValue1 = _uniformRand.URandVal(0, 1);
// Random search direction.
for (int w = 0; w < _drnd.Count; w++)
{
_drnd[w] = _normalRand.NRandVal(0, 1);
}
_drnd.MultiplyByInplace(1 / _drnd.Norm());
// If exist OSD.
if (_dosd != null)
{
randomValue2 = _uniformRand.URandVal(0, 1);
for (int coordIndex = 0; coordIndex < _dgrs.Count; coordIndex++)
{
_dgrs[coordIndex] = _mosd * randomValue1 * _dosd[coordIndex] + (1 - _mosd) * randomValue2 * _drnd[coordIndex];
}
_dgrs.MultiplyByInplace(1 / _dgrs.Norm());
randomValue1 = Math.Pow(randomValue1, p) * _radiusExplosion;
for (int coordIndex = 0; coordIndex < _dgrs.Count; coordIndex++)
{
tempPoint[coordIndex] = _grenades[WhichGrenade].Point[coordIndex] + randomValue1 * _dgrs[coordIndex];
}
}
else
{
randomValue1 = Math.Pow(randomValue1, p) * _radiusExplosion;
for (int coordIndex = 0; coordIndex < _dgrs.Count; coordIndex++)
{
tempPoint[coordIndex] = _grenades[WhichGrenade].Point[coordIndex] + randomValue1 * _drnd[coordIndex];
}
}
double randNum = 0.0, largeComp = 0.0;
// Out of range [-1; 1]^n.
for (int j = 0; j < Dimension; j++)
{
if (tempPoint[j] < -1 || tempPoint[j] > 1)
{
randNum = _uniformRand.URandVal(0, 1);
largeComp = tempPoint.Max(num => Math.Abs(num));
double normPos = 0.0;
for (int coordIndex = 0; coordIndex < tempPoint.Count; coordIndex++)
{
normPos = tempPoint[coordIndex] / largeComp;
tempPoint[coordIndex] = randNum * (normPos - _grenades[WhichGrenade].Point[coordIndex]) + _grenades[WhichGrenade].Point[coordIndex];
}
break;
}
}
double dist = 0.0;
// Calculate distance to grenades.
for (int idxGren = 0; idxGren < _parameters.NGrenade; idxGren++)
{
if (idxGren != WhichGrenade)
{
dist = PointND.Distance(tempPoint, _grenades[idxGren].Point);
// Shrapnel does not accept (it is too near to other grenades).
if (dist <= _radiusGrenade)
{
isShrapnelAdd = false;
break;
}
}
}
if (isShrapnelAdd)
{
_shrapnels[WhichGrenade].AddLast(new Agent(tempPoint, new PointND(0.0, 1)));
}
}
}
