/**
* Método que verifica se a regra passa como parâmetro é igual nos atributo discreto e se todos
* atributos numericos contem um intervalo que se cruzem
*
* @param r2 Regra a ser compararada com a atual
* @return true se as regras se cruzam, false se são diferentes
*/
public boolean verificarIntervalos(Regra r2) {
if (this.cabeca != r2.cabeca) return false;
for (int i = 0; i < corpo.length; i++) {
Atributo at1 = this.corpo[i];
Atributo at2 = r2.corpo[i];
// Se o atributo das duas regras forem vazio o atributo tem o valor igual
// Se uma é vazio e a outra não as regras são diferentes
// Se as duas não são vazias, deve ser comparado o valor dos atributos.
if (at1.isVazio()) {
if (!at2.isVazio()) return false;
} else {
if (at2.isVazio()) return false;
else {
if (at1.isNominal()) {
double[] v1 = at1.getValores();
double[] v2 = at2.getValores();
if ((v1[0] != v2[0]) || (v1[1] != v2[1])) return false;
} else {
double[] v1 = at1.getValores();
double[] v2 = at2.getValores();
if ((v1[1] < v2[0]) || v2[1] < v1[0]) return false;
}
}
}
}
return true;
}
/**
* Funcion que avisa si la clase que tiene la muestra es igual que la pasada por parametro
*
* @param original Atributo Clase a comparar con la que contiene la muestra
* @return boolean Booleano que indica si la clase es igual (true) o no (false)
*/
public boolean estaClase(Atributo original) {
boolean devolver;
String s1 = clase.getValor();
String s2 = original.getValor();
if (s1.equals(s2)) return true;
else return false;
}
public Atributo findAtr(String str) {
for (Atributo a : _atributos) {
if (str.equals(a.getNombre())) {
return a;
}
}
return null;
}
/**
* Método que verifica se a regra cobre o exemplo passado como parâmetro
*
* @param c Array com os valores do exemplo
* @return Se a regra cobre ou não o exemplo
*/
public boolean compararCorpo(double[] c) {
for (int i = 0; i < corpo.length; i++) {
Atributo atributo = corpo[i];
if (!atributo.isVazio()) {
if (!atributo.compararValor(c[i])) return false;
}
}
return true;
}
/** Método que retorna o número de atributos da regra */
public int getNumAtributosNaoVazios() {
atributosNaoVazios = 0;
for (int i = 0; i < corpo.length; i++) {
Atributo a = corpo[i];
if (!a.isVazio()) atributosNaoVazios++;
}
return atributosNaoVazios;
}
/** Método que verifica se duas regras são iguais */
public boolean equals(Object o) {
Regra r = (Regra) o;
for (int i = 0; i < corpo.length; i++) {
Atributo atributo1 = corpo[i];
Atributo atributo2 = r.corpo[i];
if (!atributo1.equals(atributo2)) return false;
}
if (cabeca == r.cabeca) return true;
else return false;
}
/**
* Método que verifica se a regra passada como parameto é generica em relação à regra atual. Uma
* regra eh generica se suas matriz de contingencias sao iguais, se os atributos discretos sao
* iguais e se seus atributos numericos sao cobertos
*
* @param r Regra que será verificada se eh generica ou nao.
* @return True se r é generica
*/
public boolean isGeneric(Regra r) {
boolean matrizes = matrizContigencia.equals(r.matrizContigencia);
if (matrizes) {
for (int i = 0; i < corpo.length; i++) {
Atributo atributo1 = corpo[i];
Atributo atributo2 = r.corpo[i];
boolean g = atributo1.isGeneric(atributo2);
if (!g) return false;
}
return true;
} else {
return false;
}
}
/**
* Método que faz um merge da regra passada como parâmetro com a regra atual. Só executa o merge
* nos atributos númericos, os atributos discretos ficam iguais à regra atual. Deve ser usada após
* a verificação se as retas se cruzam.
*
* @param r2 Regra a ser aglutinada com a atual
* @return true casa haja um merge, false caso nao
*/
public boolean merge(Regra r2) {
boolean c = this.verificarIntervalos(r2);
// Caso as regras se cruzem, elas podem ser juntas.
if (c) {
for (int i = 0; i < corpo.length; i++) {
Atributo at1 = this.corpo[i];
if (at1.isNumerico()) {
Atributo at2 = r2.corpo[i];
if (!at1.isVazio()) {
double[] v1 = at1.getValores();
double[] v2 = at2.getValores();
// Se o limite inferior da regras passada como parametro for menor,
// o limite da regra atual é alterado
if (v2[0] < v1[0]) v1[0] = v2[0];
// Mesmo procedimento, agora para o limite superior
if (v2[1] > v1[1]) v1[1] = v2[1];
at1.atualizar(v1[0], v1[1]);
}
}
}
}
return c;
}
/**
* Método que preencher uma regra atraves de um array de valores obtido pela nuvem de particulas
*
* @param novosValores Array com os novos valores para a a regra
*/
public void preencherRegraArray(double[] novosValores) {
int j = 0;
for (int i = 0; i < corpo.length; i++) {
Atributo atributo = corpo[i];
if (atributo.isNominal()) {
// Diminui o valor de 1 para voltar aos valores normais no padrao do weka (vazio == -1).
double valor = novosValores[j++] - 1;
atributo.atualizar(valor, AtributoNominal.igual);
} else {
AtributoNumerico a = (AtributoNumerico) atributo;
double valor1 = novosValores[j++];
double valor2 = novosValores[j++];
if ((valor1 == valor2) && (valor1 == a.limiteMinimo || valor1 == a.limiteMaximo))
atributo.atualizar(Double.MIN_VALUE, Double.MIN_VALUE);
else atributo.atualizar(valor1, valor2);
}
}
getNumAtributosNaoVazios();
}
/**
* Modulo que imprime por pantalla todas las condiciones de la muestra, seguidas de su clase
* correspondiente
*/
public void imprimir() {
String valor;
Atributo at;
int i;
for (i = 0; i < condiciones.size() - 1; i++) {
at = (Atributo) condiciones.get(i);
valor = at.getValor();
System.out.print(valor + " AND ");
}
// La ultima iteracion no se pinta el AND
at = (Atributo) condiciones.get(i);
valor = at.getValor();
System.out.print(valor);
// Ultima iteracion
valor = clase.getValor();
System.out.print(" ---> " + valor + " \n");
}
/**
* Prencher o atributo nominal na posicao pos
*
* @param pos Posicao do atributo
* @param att Tipo do atributo representado atraves do tipo Attribute
*/
public void preencherAtributoNominalAleatorio(int pos, Atributo atributo) {
if (!atributo.isCombinacao()) {
AtributoNominal atNom = (AtributoNominal) atributo;
double random = atNom.obterNovoValorAleatorio();
double operador = AtributoNominal.igual;
corpo[pos].atualizar(random, operador);
} else {
AtributoCombinado atComb = (AtributoCombinado) atributo;
double random = atComb.obterNovoValorAleatorio();
corpo[pos].atualizar(random, atComb.att.numValues());
}
}
/**
* Método que retorna os valores dos atributos no formato de array. Utilizado no metodo de nuvem
* de partículas
*
* @return Todos os valores dos atributos no formato array
*/
public double[] obterCorpoArray() {
ArrayList<Double> valoresAtributos = new ArrayList<Double>();
for (int i = 0; i < corpo.length; i++) {
Atributo atributo = corpo[i];
double[] valores = atributo.getValores();
if (atributo.isNominal()) {
// Caso o atributo seja nominal só é adicionado o valor do atributo.
if (atributo.isVazio()) valoresAtributos.add(new Double(0));
else {
// Adicao de 1 no valor do atributo para representar o valor vazio como sendo 0;
double temp = valores[0] + 1;
valoresAtributos.add(new Double(temp));
}
} else {
// Caso seja numerico, os dois valores do limite sao adicionados.
AtributoNumerico a = (AtributoNumerico) atributo;
if (atributo.isVazio()) {
valoresAtributos.add(new Double(a.limiteMinimo));
valoresAtributos.add(new Double(a.limiteMinimo));
} else {
valoresAtributos.add(new Double(valores[0]));
valoresAtributos.add(new Double(valores[1]));
}
}
}
// Gerar regras somente de uma classe
// valoresAtributos.add(new Double(cabeca+1));
double[] retorno = new double[valoresAtributos.size()];
int i = 0;
for (Iterator<Double> iter = valoresAtributos.iterator(); iter.hasNext(); ) {
Double valor = (Double) iter.next();
retorno[i++] = valor.doubleValue();
}
return retorno;
}
/**
* @deprecated Método com erro Método que verifica se uma regra eh generica em relacao a outra *
* @param r Regra a ser comparada
* @return -1 a regra r é genérica em relação a atual, 0 as regras sao diferentes, 1 a regra atual
* é genérica em relação a regra passada como parâmetro.
*/
public int isGeneric2(Regra r) {
boolean matrizes = matrizContigencia.equals(r.matrizContigencia);
if (matrizes) {
int[] generic = new int[corpo.length];
for (int i = 0; i < corpo.length; i++) {
Atributo atributo1 = corpo[i];
Atributo atributo2 = r.corpo[i];
int g = 1;
atributo1.isGeneric(atributo2);
if (g == 0) {
if (atributo1.isVazio())
// Caso os atributos sejam diferentes, mas o primeiro seja vazio, ele é generico
// em relacao ao segundo
generic[i] = 1;
else {
if (atributo2.isVazio())
// Caso os atributos sejam diferentes, mas o segundo seja vazio, ele é generico
// em relacao ao segundo
generic[i] = -1;
else generic[i] = g;
}
} else generic[i] = g;
}
int sinal = 2;
for (int i = 0; i < generic.length; i++) {
if (generic[i] == 0) return 0;
if (generic[i] == -1) {
if (sinal == 1) return 0;
else sinal = -1;
} else {
if (generic[i] == 1)
if (sinal == -1) return 0;
else sinal = 1;
}
}
return sinal;
} else return 0;
}
