Пример #1
0
  /**
   * 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;
  }
Пример #2
0
  /**
   * 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;
  }
Пример #3
0
 /**
  * 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;
 }
Пример #4
0
  /** 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;
  }
Пример #5
0
  /**
   * 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;
  }
Пример #6
0
 /**
  * @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;
 }