Esempio n. 1
0
        /// <summary>
        ///  Determina las menor distancia de cada demanda a  una instalacion mas cercana
        /// </summary>
        /// <param name="PosInstalaciones"></param>
        /// <param name="MyAlgorithm"></param>
        /// <returns name="menoresDistancias"></returns>
        public static List <KeyValuePair <int, double> > DeterminarMenoresDistanciasX(Algorithm MyAlgorithm, List <int> PosInstalaciones)
        {
            var menoresDistancias = new List <KeyValuePair <int, double> >();

            for (var i = 0; i < MyAlgorithm.MyProblem.NumVertices; i++)
            {
                var disMin  = 99999999;
                var PosInst = -1;
                for (var t = 0; t < PosInstalaciones.Count; t++)
                {
                    var dist = MyAlgorithm.MyProblem.DistanciasFloyd[i][PosInstalaciones[t]];
                    if (dist < disMin)
                    {
                        disMin = dist;
                    }
                    PosInst = PosInstalaciones[t];
                }
                menoresDistancias.Add(new KeyValuePair <int, double>(PosInst, disMin));
            }
            return(menoresDistancias);
        }
Esempio n. 2
0
        /// <summary>
        ///  Determina la instalacion que al eliminarna aumente al mimimo el  valor la funcion objetivo
        /// </summary>
        /// <param name="menoresDistancias"></param>
        /// <param name="PosInstalaciones"></param>
        /// <param name="MyAlgorithm"></param>
        /// <returns name="poskX"></returns>
        public static int DeterminarPosArgMin(List <KeyValuePair <int, double> > menoresDistancias, List <int> PosInstalaciones, Algorithm MyAlgorithm)
        {
            var sumasGanaciasEliminacion = new List <KeyValuePair <int, double> >();

            for (var j = 0; j < PosInstalaciones.Count; j++)
            {
                double     sumaMin             = 0;
                List <int> copiapInstalaciones = new List <int>(PosInstalaciones);
                copiapInstalaciones.RemoveAt(j);
                for (var i = 0; i < menoresDistancias.Count; i++)
                {
                    var distancias = new List <double>();
                    for (var t = 0; t < copiapInstalaciones.Count; t++)
                    {
                        var dist = MyAlgorithm.MyProblem.DistanciasFloyd[i][copiapInstalaciones[t]];
                        distancias.Add(dist);
                    }
                    sumaMin += distancias.Min() - menoresDistancias[i].Value;
                }
                sumasGanaciasEliminacion.Add(new KeyValuePair <int, double>(PosInstalaciones[j], sumaMin));
            }
            var min   = sumasGanaciasEliminacion.Min(x => x.Value);
            var poskX = sumasGanaciasEliminacion.Find(x => Math.Abs(x.Value - min) < 1e-10);

            return(poskX.Key);
        }
Esempio n. 3
0
        /// <summary>
        ///  Actualiza  la menor distancia de las  demandas de la instalacion eliminada
        /// </summary>
        /// <param name="PosInstalaciones"></param>
        /// <param name="MyAlgorithm"></param>
        /// <returns name="menoresDistancias"></returns>

        public static List <KeyValuePair <int, double> > ActualizarMenoresDistanciasEliminacion(Algorithm MyAlgorithm, int posk, List <KeyValuePair <int, double> > menoresDistancias, List <int> PosInstalaciones)
        {
            for (var i = 0; i < MyAlgorithm.MyProblem.NumVertices; i++)
            {
                if (menoresDistancias[i].Key == posk)
                {
                    var disMin  = 99999999;
                    var PosInst = -1;
                    for (var t = 0; t < PosInstalaciones.Count; t++)
                    {
                        var dist = MyAlgorithm.MyProblem.DistanciasFloyd[i][PosInstalaciones[t]];
                        if (dist < disMin)
                        {
                            disMin = dist;
                        }
                        PosInst = PosInstalaciones[t];
                    }
                    menoresDistancias[i] = new KeyValuePair <int, double>(PosInst, disMin);
                }
            }
            return(menoresDistancias);
        }
Esempio n. 4
0
        /// <summary>
        ///  Determina la instalacion que al agregarla disminuya al maximo el valor la funcion objetivo
        /// </summary>
        /// <param name="menoresDistancias"></param>
        /// <param name="MyAlgorithm"></param>
        /// <param name="Vertices"></param>
        /// <returns name="poskX"></returns>
        public static int DeterminarPosArgMax(List <KeyValuePair <int, double> > menoresdistancias, Algorithm myalgorithm, int[] vertices)
        {
            var sumasperdidasadicion = new List <KeyValuePair <int, double> >();

            for (var j = 0; j < myalgorithm.MyProblem.NumVertices; j++)
            {
                if (vertices[j] == 0)
                {
                    double sumamin = 0;
                    for (var i = 0; i < menoresdistancias.Count; i++)
                    {
                        var distanciaij = myalgorithm.MyProblem.DistanciasFloyd[i][j];
                        var dif         = distanciaij - menoresdistancias[i].Value;
                        if (dif < 0)
                        {
                            sumamin += dif * -1;
                        }
                    }
                    sumasperdidasadicion.Add(new KeyValuePair <int, double>(j, sumamin));
                }
            }
            var max   = sumasperdidasadicion.Max(x => x.Value);
            var poskx = sumasperdidasadicion.Find(x => Math.Abs(x.Value - max) < 1e-10);

            return(poskx.Key);
        }
Esempio n. 5
0
 /// <summary>
 ///  Actualiza la menor distancia de cada una de las demandas con la nueva  instalacion
 /// </summary>
 /// <param name="PosInstalaciones"></param>
 /// <param name="MyAlgorithm"></param>
 /// <returns name="menoresDistancias"></returns>
 public static List <KeyValuePair <int, double> > ActualizarMenoresDistanciasAgregacion(Algorithm myalgorithm, int posk, List <KeyValuePair <int, double> > menoresdistancias)
 {
     for (var i = 0; i < myalgorithm.MyProblem.NumVertices; i++)
     {
         var dist = myalgorithm.MyProblem.DistanciasFloyd[i][posk];
         if (dist < menoresdistancias[i].Value)
         {
             menoresdistancias[i] = new KeyValuePair <int, double>(posk, dist);
         }
     }
     return(menoresdistancias);
 }