void ProcesadorConsulta::filtrarPosiciones(list<int> & posiciones, Posicion posicion)
{
list<int> pos = posicion.getPosiciones();
list<int> :: iterator itPosiciones = pos.begin();
posiciones.push_back(*itPosiciones);
}
int ProcesadorConsulta::procesarPosiciones(list<Posicion> & posiciones)
{
list<Posicion> :: iterator itPosiciones = posiciones.begin();
list<int> pos;
list<Posicion> posicionesMinimas;
int distancia = -1;
Posicion posicionActual = *itPosiciones;
++itPosiciones;
Posicion posicionSiguiente;
Posicion posicionCalculada;
bool procesar = true;
while(itPosiciones != posiciones.end() && procesar)
{
posicionSiguiente = *itPosiciones;
posicionCalculada = this->compararPosiciones(posicionActual,posicionSiguiente,posicionesMinimas);
posicionActual = posicionCalculada;
if(posicionCalculada.getPosiciones().size() == 0)
procesar = false;
++itPosiciones;
}
//Actualizo la lista de posiciones con la minima.
posiciones.clear();
list<Posicion> :: iterator itPosicionesMinimas = posicionesMinimas.begin();
while(itPosicionesMinimas != posicionesMinimas.end())
{
Posicion posActual = *itPosicionesMinimas;
posiciones.push_back(posActual);
itPosicionesMinimas++;
}
itPosicionesMinimas = posicionesMinimas.begin();
//Una vez que tenemos todas las posiciones en una misma lista las comparamos
while(itPosicionesMinimas != posicionesMinimas.end())
{
Posicion posicionActual = *itPosicionesMinimas;
this->filtrarPosiciones(pos,posicionActual);
++itPosicionesMinimas;
}
if(procesar)
distancia = compararPosiciones(pos);
return distancia;
}
list<int> ProcesadorConsulta::filtrarRanqueada(Palabra palabra)
{
list<int> documentos;
// cantidadApariciones representa la cantidad de libros donde hay coincidencias
int cantidadApariciones = (palabra.getApariciones()).size();
int frecTerminoEnDoc = 0;
list<Aparicion>::iterator itAparicionFiltrada;
list<Posicion> posicionEnDoc;
list<Posicion>::iterator itPosicionEnDoc;
list<int>::iterator itPosicionDocumentos;
Aparicion aparicion;
Posicion posicion;
float pesoGlobal, mayorPeso, pesoTerminosEnDocumento, normaDocumento, sumaParcial;
CalculadorDePesoGlobal calcPesoGlobal;
int cantPalabras = 0;
int cantDocumentosTermino = 0;
list<Aparicion> apariciones = palabra.getApariciones();
ProcesadorNorma procesadorNorma;
itAparicionFiltrada = apariciones.begin();
// por cada documento hay una aparicion
for (int a = 0; a<cantidadApariciones; a++){
sumaParcial = 0;
pesoTerminosEnDocumento = 0;
aparicion = *itAparicionFiltrada;
// Calculo el peso:
// para eso recorro la lista de posiciones (cada una representa a una palabra) y calculo su peso y su frecuencia
cantPalabras = (aparicion.getPosiciones()).size();
posicionEnDoc = aparicion.getPosiciones();
itPosicionEnDoc = posicionEnDoc.begin();
for (int c = 0; c < cantPalabras; c++){
posicion = *itPosicionEnDoc;
frecTerminoEnDoc = (posicion.getPosiciones()).size();
cantDocumentosTermino = procesadorNorma.buscarPesoTermino(posicion.getIdPalabra());
pesoGlobal = calcPesoGlobal.calcularPesoGlobalTermino(cantDocumentosTermino);
sumaParcial += frecTerminoEnDoc * pesoGlobal;
++itPosicionEnDoc;
}
normaDocumento = procesadorNorma.consultarNorma(aparicion.getIdDocumento());
pesoTerminosEnDocumento = sumaParcial / normaDocumento;
// Si la lista de documentos esta vacia, no importa el peso que tenga, sera siempre el de mayor peso hasta ahora
if (documentos.empty()){
documentos.push_back(aparicion.getIdDocumento());
mayorPeso = pesoTerminosEnDocumento;
} else {
// Comparo pesos
if (pesoTerminosEnDocumento > mayorPeso){
int cantDocumentosADevolver = documentos.size();
// Vacio la lista de documentos
for (int d = 0; d<cantDocumentosADevolver; d++){
documentos.pop_back();
}
// Inserto el id del documento con mayor peso
documentos.push_back(aparicion.getIdDocumento());
mayorPeso = pesoTerminosEnDocumento;
} else if (pesoTerminosEnDocumento == mayorPeso){
// Si el peso es el mismo, agrego el id del documento a la lista
documentos.push_back(aparicion.getIdDocumento());
}
}
++itAparicionFiltrada;
}
return documentos;
}
Posicion ProcesadorConsulta::compararPosiciones(Posicion posicionActual, Posicion posicionSiguiente, list<Posicion> & posicionesMinimas)
{
list<int> posiciones1 = posicionActual.getPosiciones();
list<int> posiciones2 = posicionSiguiente.getPosiciones();
list<int> :: iterator itPosiciones1 = posiciones1.begin();
list<int> :: iterator itPosiciones2;
int distanciaMinima = 0;
int distanciaMinimaAnterior = 0;
Posicion posicionMinima;
while(itPosiciones1!= posiciones1.end())
{
int pos1Actual = *itPosiciones1;
itPosiciones2 = posiciones2.begin();
while(itPosiciones2 != posiciones2.end())
{
int pos2Actual = *itPosiciones2;
if(pos1Actual < pos2Actual)
{
distanciaMinima = abs(pos2Actual - pos1Actual);
if(distanciaMinimaAnterior == 0)
distanciaMinimaAnterior = distanciaMinima;
if(distanciaMinima < distanciaMinimaAnterior)
{
distanciaMinimaAnterior = distanciaMinima;
posicionesMinimas.clear();
crearPosicionesNuevas(posicionActual.getPalabra(),pos1Actual,posicionSiguiente.getPalabra(),pos2Actual,posicionesMinimas);
}
else
if(distanciaMinima == distanciaMinimaAnterior)
crearPosicionesNuevas(posicionActual.getPalabra(),pos1Actual,posicionSiguiente.getPalabra(),pos2Actual,posicionesMinimas);
}
itPosiciones2++;
}
itPosiciones1++;
}
list<Posicion> :: iterator itPosicionesMinimas = posicionesMinimas.begin();
bool encontrado = false;
while(itPosicionesMinimas != posicionesMinimas.end() && !encontrado)
{
Posicion posicionActual = *itPosicionesMinimas;
if(posicionActual.getPalabra() == posicionSiguiente.getPalabra())
{
posicionMinima = posicionActual;
encontrado = true;
}
itPosicionesMinimas++;
}
return posicionMinima;
}
