示例#1
0
 /** Returns a string representation of the rule case. */
 @Override
 public String toString() {
   String str = "";
   if (!(condition instanceof VoidCondition)) {
     str += "if (" + condition.toString() + ") then ";
   } else {
     str += " ";
   }
   str += output.toString();
   return str;
 }
示例#2
0
  /**
   * Returns the first rule output whose condition matches the input assignment provided as
   * argument. The output contains the grounded list of effects associated with the satisfied
   * condition.
   *
   * @param input the input assignment
   * @return the matched rule output.
   */
  public RuleOutput getOutput(Assignment input) {

    RuleOutput output = new RuleOutput(ruleType);
    RuleGrounding groundings = getGroundings(input);
    for (Assignment g : groundings.getAlternatives()) {

      Assignment full = !(g.isEmpty()) ? new Assignment(input, g) : input;

      RuleOutput match =
          cases
              .stream()
              .filter(c -> c.condition.isSatisfiedBy(full))
              .map(c -> c.output)
              .findFirst()
              .orElse(new RuleOutput(ruleType));

      match = match.ground(full);
      output.addOutput(match);
    }

    return output;
  }
示例#3
0
    /**
     * Returns the groundings associated with the rule case, given the input assignment
     *
     * @param input the input assignment
     * @return the resulting groundings
     */
    public RuleGrounding getGroundings(Assignment input) {
      RuleGrounding groundings = new RuleGrounding();
      groundings.add(condition.getGroundings(input));

      if (ruleType == RuleType.UTIL) {
        boolean actionVars = input.containsVars(output.getOutputVariables());
        for (Effect e : getEffects()) {
          if (actionVars) {
            Condition co = e.convertToCondition();
            RuleGrounding effectGrounding = co.getGroundings(input);
            groundings.add(effectGrounding);
          } else {
            Set<String> slots = e.getValueSlots();
            slots.removeAll(input.getVariables());
            groundings.add(Assignment.createOneValue(slots, ""));
          }
        }
      }
      return groundings;
    }
示例#4
0
  /**
   * Adds a new case to the abstract rule
   *
   * @param condition the condition
   * @param output the corresponding output
   */
  public void addCase(Condition condition, RuleOutput output) {
    if (!cases.isEmpty() && cases.get(cases.size() - 1).condition instanceof VoidCondition) {
      log.warning("new case for rule " + id + " is unreachable (previous case is trivially true)");
    }

    // ensuring that the probability values are between 0 and 1
    if (ruleType == RuleType.PROB) {
      double totalMass = 0;
      for (Parameter p : output.getParameters()) {
        if (p instanceof FixedParameter) {
          double v = ((FixedParameter) p).getValue();
          if (v < 0.0) {
            throw new RuntimeException("probability value must be >=0");
          }
          totalMass += v;
        }
      }
      if (totalMass > 1) {
        throw new RuntimeException("probability value must be <=1");
      }
    }
    cases.add(new RuleCase(condition, output));
  }
示例#5
0
 /**
  * Returns the set of effects for the rule case
  *
  * @return the set of effects
  */
 public Set<Effect> getEffects() {
   return output.getEffects();
 }