functionbuildertest.java

用java语言写的遗传算法库

  /**
   * Three complex terms, first and second depth 2, two operators (one block)
   */
  public void testFormula_8() {
    Vector elements = new Vector();
    Term element = new Term(2, "exp", 2);
    elements.add(element);
    element = new Term(2, "abs", 2);
    elements.add(element);
    element = new Term(1, "16.4", 1);
    elements.add(element);
    element = new Term(1, "X", 1, '+');
    elements.add(element);
    element = new Term(2, "cos", 1, '*');
    elements.add(element);
    element = new Term(1, "347.2", 1);
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=exp(abs(16.4+X)*cos(347.2))", formula);
  }

  /**
   * Three complex terms and one simple term, first and second depth 2, three operators (two block)
   */
  public void testFormula_9() {
    Vector elements = new Vector();
    Term element = new Term(2, "exp", 2);
    elements.add(element);
    element = new Term(2, "abs", 2);
    elements.add(element);
    element = new Term(1, "16.4", 1);
    elements.add(element);
    element = new Term(1, "X", 1, '+');
    elements.add(element);
    element = new Term(2, "cos", 1, '*');
    elements.add(element);
    element = new Term(1, "347.2", 1);
    elements.add(element);
    element = new Term(1, "X", 1, '%');
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=exp(abs(16.4+X)*cos(347.2))%X", formula);
  }

  /**
   * Four complex terms, first and second depth 2, three operators (two block)
   */
  public void testFormula_10() {
    Vector elements = new Vector();
    Term element = new Term(2, "exp", 2);
    elements.add(element);
    element = new Term(2, "abs", 2);
    elements.add(element);
    element = new Term(1, "16.4", 1);
    elements.add(element);
    element = new Term(1, "X", 1, '+');
    elements.add(element);
    element = new Term(2, "cos", 1, '*');
    elements.add(element);
    element = new Term(1, "347.2", 1);
    elements.add(element);
    element = new Term(2, "sqrt", 1, '%');
    elements.add(element);
    element = new Term(1, "X", 1);
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=exp(abs(16.4+X)*cos(347.2))%sqrt(X)", formula);
  }

  /**
   * Two formulas, depth 1, one operator, one term too less
   * Two illegal operators and two depth point to much are expected to be ignored
   */
  public void testFormula_11() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 1, '+');
    elements.add(element);
    element = new Term(1, "X", 1, '~');
    elements.add(element);
    element = new Term(2, "cos", 2, '*');
    elements.add(element);
    element = new Term(1, "27.5", 1);
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X)*cos(27.5)", formula);
  }

  /**
   * Two formulas, depth 1, one operator, two terms too less
   * Two illegal operators and two depth points too much are expected to be ignored
   */
  public void testFormula_12() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 2, '+');
    elements.add(element);
    element = new Term(1, "X", 1, '~');
    elements.add(element);
    element = new Term(2, "cos", 2, '*');
    elements.add(element);
    element = new Term(1, "27.5", 1);
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X*cos(27.5))", formula);
  }

  /**
   * Two formulas, depth 1, one operator, several terms too less
   * Two illegal operators and several depth points too much are expected to be ignored
   */
  public void testFormula_13() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 3, '+');
    elements.add(element);
    element = new Term(1, "X", 1, '~');
    elements.add(element);
    element = new Term(2, "cos", 3, '*');
    elements.add(element);
    element = new Term(1, "27.5", 2,'!');
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X*cos(27.5))", formula);
  }

  /**
   * One formula, one operator, one constant too less
   */
  public void testFormula_14() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 1, '+');
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X)", formula);
  }

  /**
   * Two formulas, depth 1, one operator, one constant too less
   */
  public void testFormula_15() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 3, '+');
    elements.add(element);
    element = new Term(1, "X", 1, '~');
    elements.add(element);
    element = new Term(2, "cos", 1, '*');
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X*cos(X))", formula);
  }

  /**
   * Two formulas, depth 1, one operator, one constant too less
   */
  public void testFormula_16() {
    Vector elements = new Vector();
    Term element = new Term(2, "sin", 3, '+');
    elements.add(element);
    element = new Term(1, "X", 1, '~');
    elements.add(element);
    element = new Term(2, "cos", 2, '*');
    elements.add(element);
    String formula = getFormula(elements);
    assertFormula("F(X)=sin(X*cos(X))", formula);
  }

  /**
   * Hilfsroutine, gibt Soll- und Istwert aus. assertEquals tut dies auch, aber
   * die Ausgabe ist bei l鋘geren Zeichenfolgen abgeschnitten
   * @param soll
   * @param ist
   */
  protected void assertFormula(String soll, String ist) {
    try {
      assertEquals(soll, ist);
    }
    catch (ComparisonFailure cof) {
      System.err.println("Ist : " + ist);
      System.err.println("Soll: " + soll);
      //rethrow the exception
      assertEquals(soll, ist);
    }
  }

  public static String getFormulaFromChromosome(Chromosome chromosome) {
    /**@todo constructTerms allgemeiner machen (Object zur點kliefern),
     * in Methode selbst das mit CompositeGene durch Call auf Plugin ersetzen
     */
    Vector terms = GeneExtractorTest.constructTerms(chromosome.getGenes());
    return getFormula(terms);
  }

  /**
   * Constructs a formula string out of terms (each holding operators, if relevant)
   * @param elements vector with ordered list of terms
   * @return constructed formula
   */
  public static String getFormula(Vector elements) {
    if (elements == null || elements.isEmpty()) {
      return "";
    }
    else {
      String result = "";
      Term element = null;
      boolean addKlammer = false;
      do {
        element = (Term) elements.elementAt(0);
        result += getFormula_int(elements, result);
      }
      while (elements.size() > 0);
      if (result == "") {
        return "";
      }
      else {
        return "F(X)=" + result;
      }
    }
  }

  /**
   * Recursive part of getFormula
   * @param elements vector with ordered list of terms
   * @return constructed part of formula
   */
  protected static String getFormula_int(Vector elements, String previous) {
    if (elements.size() < 1) {
      return "";
    }
    Term element = (Term) elements.elementAt(0);
    element = replaceSubstitute(element);
    String result = "";
    //ignore illegal operator specification
    if (element.operator != ' ' && previous.length() > 0 && !previous.endsWith("(")) {
      result += element.operator;
    }
    int type = element.termType;
    result += element.termName;
    elements.remove(0);
    if (type == 2) {
      result += "(";
      boolean compensationPossible = true;
      do {
        element.depth--;
        String tempRes = getFormula_int(elements, result);
        if (tempRes.length() > 0) {
          compensationPossible = false;
        }
        result += tempRes;
      }
      while (element.depth > 0);
      if (compensationPossible) {
        result += "X";
      }
      result += ")";
    }
    else if (type == 1) {
      /**@todo nicht ben鰐igt?*/
      element.depth--;
    }
    else {
      throw new RuntimeException("Ung黮tiger Operatortyp: " + type);
    }
    return result;
  }

  private static Term replaceSubstitute(Term element) {
    if (element.termName.equals("+I")) {
      /**@todo: optional Wertebereich angeben k鰊nen*/
      element.termName = String.valueOf(new Random().nextInt(3)+1);
    }
    else if (element.termName.equals("-I")) {
      element.termName = String.valueOf(-(new Random().nextInt(10)+1));
    }
    else if (element.termName.equals("+D")) {
      element.termName = String.valueOf(new Random().nextDouble()*10);
    }
    else if (element.termName.equals("-D")) {
      element.termName = String.valueOf(-(new Random().nextDouble()*10));
    }
    return element;
  }
}