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