Esempio n. 1
0
        /// <summary>
        /// Metodo de ordenamiento QuickSort
        /// </summary>
        /// <param name="_iColumna">Columna en la que se basa para ordenar las filas</param>
        /// <param name="_bTipo">Tipo de ordenamiento</param>
        /// <param name="_bConcurrencia">Indica si se ordena de forma concurrente o no</param>
        /// <returns>Retorna el tiempo de ejecucion de la funcion</returns>
        public static string quickSort(int _iColumna, bool _bTipo, bool _bConcurrencia)
        {
            clsArchivo insArchivo = new clsArchivo();
            List<string> aoLineas = insArchivo.cargarArchivo();
            int iSegmento = (aoLineas.Count / 3) + 1;
            StringBuilder sbTexto = new StringBuilder();

            var vTiempo = Stopwatch.StartNew();

            /* ***************************************************************************************** */
            if (_bConcurrencia)
            {
                StringBuilder sbTextoTmp1 = new StringBuilder();
                StringBuilder sbTextoTmp2 = new StringBuilder();
                var vLista = aoLineas.Select((x, i) => new { Index = i, Value = x })
                                      .GroupBy(x => x.Index / iSegmento)
                                      .Select(x => x.Select(v => v.Value).ToList())
                                      .ToList();
                aoLineas = null;
                Parallel.Invoke(
                    () =>
                    {
                        sbTexto = quickSort(vLista.ElementAt(0), _iColumna, _bTipo, _bConcurrencia);
                    },
                    () =>
                    {
                        sbTextoTmp1 = quickSort(vLista.ElementAt(1), _iColumna, _bTipo, _bConcurrencia);
                    },
                    () =>
                    {
                        sbTextoTmp2 = quickSort(vLista.ElementAt(2), _iColumna, _bTipo, _bConcurrencia);
                    }
                );
                vLista = null;
                sbTexto.Append(sbTextoTmp1.Append(sbTextoTmp2.ToString()).ToString());
            }
            else /* ------------------------------------------------------------------------------------ */
            {
                sbTexto = quickSort(aoLineas, _iColumna, _bTipo, _bConcurrencia);
                aoLineas = null;
            }
            /* ***************************************************************************************** */

            vTiempo.Stop();

            insArchivo.guardarArchivo(sbTexto);

            return Convert.ToString(vTiempo.Elapsed);
        }
Esempio n. 2
0
        /// <summary>
        /// Funcion principal evalua el tiempo que dura la ejecucion
        /// </summary>
        /// <param name="_iColumna">Columna que se va a ordenar</param>
        /// <param name="_bTipo">Tipo de ordenamiento, ascendente o descendente</param>
        /// <param name="_bConcurrencia">Indica si se ejecuta de manera concurrente o no</param>
        /// <returns>retorna el tiempo de ejecucion</returns>
        public static string mergeSort(int _iColumna, bool _bTipo, bool _bConcurrencia)
        {
            clsArchivo insArchivo = new clsArchivo();
            List<string> aoLineas = insArchivo.cargarArchivo();
            int iSegmento = (aoLineas.Count / 3) + 1;
            StringBuilder sbTexto = new StringBuilder();

            var vTiempo = Stopwatch.StartNew();
            sbTexto = mergeSort(aoLineas, _iColumna, _bTipo, _bConcurrencia);
            aoLineas = null;
            vTiempo.Stop();

            insArchivo.guardarArchivo(sbTexto);

            return Convert.ToString(vTiempo.Elapsed);
        }
Esempio n. 3
0
        /// <summary>
        /// Recorre el texto analizandolo con funciones auxiliares
        /// </summary>
        /// <param name="_sTexto">Texto que se debe analizar</param>
        /// <param name="_bConcurrencia">Bandera que indica si se debe analizar con procesamiento concurrente o no</param>
        public string analizarTexto(bool _bConcurrencia)
        {
            string sPath = Directory.GetParent(Path.GetDirectoryName(Application.StartupPath)).FullName + "\\Datos\\diccionario.txt";
            clsArchivo insArvhivo = new clsArchivo();
            string[] asIdiomas = insArvhivo.cargarArchivo(sPath).Split(new char[] { '\n' });
            LinkedList<object[]> lsIdiomas = new LinkedList<object[]>();
            string[] asPalabras = insArvhivo.cargarArchivos().Split(new char[] { ' ' });
            var vTiempo = Stopwatch.StartNew();
            iCantidadPalabras = asPalabras.Length;
            object[,] moIdiomas = null;
            List<object[]> comunes = null;

            if (!String.IsNullOrEmpty(asIdiomas[0]) && iCantidadPalabras > 0)
            {
                /* ***************************************************************************************** */
                if (_bConcurrencia)
                {
                    object[] aoIdioma1 = null;
                    object[] aoIdioma2 = null;
                    object[] aoIdioma3 = null;

                    Parallel.Invoke(
                        () => { aoIdioma1 = separar(asIdiomas[0]); },
                        () => { aoIdioma2 = separar(asIdiomas[1]); },
                        () => { aoIdioma3 = separar(asIdiomas[2]); }
                    );

                    lsIdiomas.AddLast(aoIdioma1);
                    lsIdiomas.AddLast(aoIdioma2);
                    lsIdiomas.AddLast(aoIdioma3);

                    object[] aoDatos1 = null;
                    object[] aoDatos2 = null;
                    object[] aoDatos3 = null;

                    int iSegmento = (asPalabras.Length / 3) + 1;
                    var vLista = asPalabras.Select((x, i) => new { Index = i, Value = x })
                                           .GroupBy(x => x.Index / iSegmento)
                                           .Select(x => x.Select(v => v.Value).ToList())
                                           .ToList();
                    Parallel.Invoke(
                        () =>
                        {
                            aoDatos1 = analisisTextual(vLista.ElementAt(0).ToArray(), asIdiomas.Length, lsIdiomas);
                        },
                        () =>
                        {
                            aoDatos2 = analisisTextual(vLista.ElementAt(1).ToArray(), asIdiomas.Length, lsIdiomas);
                        },
                        () =>
                        {
                            aoDatos3 = analisisTextual(vLista.ElementAt(2).ToArray(), asIdiomas.Length, lsIdiomas);
                        }
                    );
                    iCantidadCaracteres = (int)aoDatos1[0] + (int)aoDatos2[0] + (int)aoDatos3[0];
                    comunes = palabrasComunes((List<object[]>)aoDatos1[1], (List<object[]>)aoDatos2[1], (List<object[]>)aoDatos3[1]);
                    moIdiomas = (object[,])aoDatos1[2];
                    moIdiomas[0, 1] = (int)moIdiomas[0, 1] + (int)((object[,])aoDatos2[2])[0, 1] + (int)((object[,])aoDatos3[2])[0, 1];
                    moIdiomas[1, 1] = (int)moIdiomas[1, 1] + (int)((object[,])aoDatos2[2])[1, 1] + (int)((object[,])aoDatos3[2])[1, 1];
                    moIdiomas[2, 1] = (int)moIdiomas[2, 1] + (int)((object[,])aoDatos2[2])[2, 1] + (int)((object[,])aoDatos3[2])[2, 1];
                }
                else /* ------------------------------------------------------------------------------------ */
                {
                    lsIdiomas = separar(asIdiomas);
                    object[] aoDatos = analisisTextual(asPalabras, asIdiomas.Length, lsIdiomas);
                    iCantidadCaracteres = (int)aoDatos[0];
                    comunes = (List<object[]>)aoDatos[1];
                    moIdiomas = (object[,])aoDatos[2];
                }
                /* ***************************************************************************************** */
            }
            identificarIdioma(moIdiomas);
            var lsPalabras = comunes.OrderByDescending(x => x[1]).ToList();
            loPalabrasComunes = new List<object[]>(lsPalabras);
            vTiempo.Stop();
            return Convert.ToString(vTiempo.Elapsed);
        }