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