public Solucion copy()
{
Solucion copy = new Solucion(vector.Length, fx, r, pesoMaximo);
copy.vector = (int[])vector.Clone();
return(copy);
}
protected Solucion apagar(Solucion nueva)
{
int tam = nueva.vector.Length;
int pos = r.Next(0, tam);
int i = pos + 1;
while (nueva.getPeso() > pesoMaximo)
{
if (i >= tam)
{
i = 0;
}
if (nueva.vector[i] == 1)
{
nueva.setPeso(nueva.getPeso() - fx.elementos[i].peso);
nueva.vector[i] = 0;
}
i++;
}
if (nueva.getPeso() > 0)
{
return(nueva);
}
else
{
return(prender(nueva));
}
}
public Particula copy(Solucion Best, double[] velocidad)
{
Particula copy = new Particula(vector.Length, fx, r, pesoMaximo);
copy.vector = (int[])vector.Clone();
copy.Best = Best;
copy.velocidad = (double[])velocidad.Clone();
return(copy);
}
public double getCalidad(Solucion s)
{
if (isMin())
{
return(Int32.MaxValue - s.getValor());
}
else
{
return(s.getValor());
}
}
protected Solucion arreglarSolucion(Solucion nueva)
{
nueva.setValor(-1);
if (opcionArreglo == 1)
{
return(repararArmonia(nueva));
}
else
{
return(contrapeso(nueva));
}
}
protected override Solucion repararArmonia(Solucion n)
{
Particula ajustada, nueva = (Particula)n;
if (nueva.getPeso() > pesoMaximo)
{
ajustada = (Particula)apagar(nueva);
}
else
{
ajustada = nueva.copy(nueva.Best, nueva.velocidad);
}
return(prender(ajustada));
}
protected override Solucion repararArmonia(Solucion nueva)
{
Solucion ajustada;
if (nueva.getPeso() > pesoMaximo)
{
ajustada = apagar(nueva);
}
else
{
ajustada = nueva.copy();
}
return(prender(ajustada));
}
public override Solucion ejecutar()
{
int i = 0;
do
{
Solucion R = tweak(Best.copy());
if (fx.getCalidad(R) > fx.getCalidad(Best))
{
Best = R.copy();
}
i++;
} while (i < numIteraciones);
return(Best);
}
public Solucion tweak(Solucion copy)
{
int posicion = buscar(copy);
if (posicion == -1)
{
copy = prender(copy);
}
else
{
copy.vector[posicion] = 0;
}
copy.setPeso(-1);
posicion = r.Next(copy.vector.Length);
while (true)
{
if (copy.getPeso() > pesoMaximo)
{
if (copy.vector[posicion] == 0)
{
posicion = buscar(copy);
}
copy.setPeso(copy.getPeso() - fx.elementos[posicion].peso);
copy.vector[posicion] = 0;
if (copy.getPeso() <= pesoMaximo && copy.getPeso() > 0)
{
break;
}
}
else
{
if (copy.vector[posicion] == 0)
{
copy.setPeso(copy.getPeso() + fx.elementos[posicion].peso);
copy.vector[posicion] = 1;
}
}
posicion = r.Next(copy.vector.Length);
}
return(copy);
}
protected Solucion prender(Solucion ajustada)
{
if (ajustada.getPeso() > pesoMaximo)
{
return(apagar(ajustada));
}
else
{
if (ajustada.getPeso() == pesoMaximo)
{
return(ajustada);
}
else
{
int tam = ajustada.vector.Length, pos = r.Next(0, tam);
ajustada.setPeso(ajustada.getPeso() + fx.elementos[pos].peso);
ajustada.vector[pos] = 1;
return(prender(ajustada));
}
}
}
public int buscar(Solucion copy)
{
int posicion = r.Next(copy.vector.Length);
int i = posicion - 1;
while (copy.vector[posicion] != 1 && i != posicion)
{
posicion++;
if (posicion >= copy.vector.Length)
{
posicion = 0;
}
}
if (copy.vector[posicion] == 1)
{
return(posicion);
}
else
{
return(-1);
}
}
protected abstract Solucion repararArmonia(Solucion nueva);
protected Solucion contrapeso(Solucion ajustada)
{
ajustada.setValor(ajustada.getValor() - (fx.getValorMaximo() * (ajustada.getPeso() - pesoMaximo)));
return(ajustada);
}
public Solucion ejecutarBusquedaLocal(Solucion p)
{
algoritmoLocal.Best = p.copy();
p = algoritmoLocal.ejecutar();
return(p);
}
public abstract double evaluarDensidad(Solucion s);
public abstract double evaluarValor(Solucion s);
public abstract double evaluarPeso(Solucion s);