/// <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);
}
/// <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);
}
/// <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);
}
