public double getErro() { double temp = matrizContigencia.getNumElementos(); if (temp != 0) erro = (matrizContigencia.getNotH_B() + matrizContigencia.getH_NotB()) / temp; else erro = 0; return erro; }
/** * Cálculo do suporte * * @return Suporte */ public double getSup() { double temp = matrizContigencia.getNumElementos(); if (temp != 0) sup = matrizContigencia.getH_B() / temp; else sup = 0; return sup; }
/** * Cálculo da confiança da regra * * @return Confiança */ public double getConfidence() { double temp = matrizContigencia.getH_B() + matrizContigencia.getNotH_B(); if (temp == 0) confianca = 0; else confianca = matrizContigencia.getH_B() / (temp); return confianca; }
/** * Método que cálcula a precisão da regra a partir da matriz de contingência * * @return Precisão da regra */ public double getACC() { double temp = matrizContigencia.getB(); if (temp != 0) acc = matrizContigencia.getH_B() / temp; else acc = 0; return acc; }
public double getAcerto() { double temp = matrizContigencia.getNumElementos(); if (temp != 0) acerto = (matrizContigencia.getH_B() + matrizContigencia.getNotH_NotB()) / temp; else acerto = 0; return acerto; }
/** * Cálculoda especificidade * * @return Especificidade */ public double getSpec() { double temp = matrizContigencia.getNotH(); if (temp != 0) spec = matrizContigencia.getNotH_NotB() / temp; else spec = 0; return spec; }
/** * Cálculo da sensitividade * * @return Sensitividade */ public double getSens() { double temp = matrizContigencia.getH(); if (temp != 0) sens = matrizContigencia.getH_B() / temp; else sens = 0; return sens; }
/** * Cálculo da Negative Relation * * @return Negative Relation */ public double getNegRel() { double temp = matrizContigencia.getNotB(); if (temp != 0) negrel = matrizContigencia.getNotH_NotB() / temp; else negrel = 0; return negrel; }
/** * Cálculo do erro. Complemento da precisão * * @return Erro */ public double getERR() { double temp = matrizContigencia.getB(); if (temp != 0) err = matrizContigencia.getNotH_B() / temp; else err = 0; return err; }
/** * Cálculoda novidade da regra * * @return Novidade */ public double getNovelty() { double fhb = matrizContigencia.getH_B() / matrizContigencia.getNumElementos(); double fh = matrizContigencia.getH() / matrizContigencia.getNumElementos(); double fb = matrizContigencia.getB() / matrizContigencia.getNumElementos(); nov = fhb - (fh * fb); return nov; }
/** * Cálculo da precisão de Laplace * * @return Precisão de Laplace */ public double getLaplace() { double temp = matrizContigencia.getB(); int numClasses = classe.numValues(); if (temp != 0) laplace = (matrizContigencia.getH_B() + 1) / (temp + numClasses); else laplace = 0; return laplace; }
/** * 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; } }
/** * Medoto que verifica se a instancia passada como parametro e igual a regra. Retorna resultados * que serao usados para a construcao da matriz de contigencia * * @param i Instancia de teste a ser comparada com a regra * @return Retorno da comparacao: 0 hb, 1 h'b, 2 hb', 3 h'b' */ public void compararRegraContigencia(Instance i) { double b[] = i.toDoubleArray(); double h = b[b.length - 1]; boolean compCorpo = compararCorpo(b); if (compCorpo) { if (cabeca == (int) h) { // Corpo e cabeca iguais - hb matrizContigencia.incH_B(); } else { // Corpo igual mas cabeca diferente - h'b matrizContigencia.incNotH_B(); } } else { if (cabeca == (int) h) { // Corpo diferente e cabeca igual - hb' matrizContigencia.incH_NotB(); } else { // Corpo e cabeca diferentes - h'b' matrizContigencia.incNotH_NotB(); } } }
public Object clone() { Regra novaRegra = new Regra(objetivos); novaRegra.cabeca = cabeca; novaRegra.classe = classe; novaRegra.confianca = confianca; /*novaRegra.attributes = new LinkedList<Attribute>(); for (Iterator iter = attributes.iterator(); iter.hasNext();) { Attribute atributo = (Attribute) iter.next(); novaRegra.attributes.add(atributo); }*/ novaRegra.corpo = new Atributo[corpo.length]; for (int i = 0; i < corpo.length; i++) { Atributo a = corpo[i].clone(); novaRegra.corpo[i] = a; } novaRegra.matrizContigencia = (MatrizContingencia) matrizContigencia.clone(); return novaRegra; }
/** * @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; }
/** * Cálculo da cobertura * * @return Cobertura */ public double getCov() { double temp = matrizContigencia.getNumElementos(); if (temp != 0) cov = matrizContigencia.getB() / temp; else cov = 0; return cov; }