public void setFramePartialTruth(
      TruthValue truthvalue, double posscore, double negscore, boolean ignorepolarityP) {
    {
      PartialMatchFrame self = this;

      {
        boolean flippolarityP = self.controlFrame.reversePolarityP && (!ignorepolarityP);

        if ((posscore == Stella.NULL_FLOAT) && (truthvalue != null)) {
          posscore = truthvalue.positiveScore;
        }
        if ((negscore == Stella.NULL_FLOAT) && (truthvalue != null)) {
          negscore = TruthValue.invertTruthValue(truthvalue).positiveScore;
        }
        if (flippolarityP) {
          {
            double aux = posscore;

            posscore = 0 - posscore;
            negscore = aux;
          }
        }
        self.positiveScore = posscore;
        self.negativeScore = negscore;
        KeyValueList.setDynamicSlotValue(
            ((QueryIterator) (Logic.$QUERYITERATOR$.get())).dynamicSlots,
            Logic.SYM_LOGIC_LATEST_POSITIVE_SCORE,
            FloatWrapper.wrapFloat(posscore),
            Stella.NULL_FLOAT_WRAPPER);
      }
    }
  }
  public void traceFramePartialTruth(Keyword lastmove, OutputStream stream) {
    {
      PartialMatchFrame self = this;

      {
        double weight = self.propositionWeight(self.controlFrame.proposition);

        if (lastmove == Logic.KWD_DOWN) {
          {
            double cutoff = self.computeDynamicCutoff();

            if (cutoff != Stella.NULL_FLOAT) {
              stream.nativeStream.print("cutoff=" + cutoff);
            }
          }
        } else if ((lastmove == Logic.KWD_UP_TRUE) || (lastmove == Logic.KWD_UP_FAIL)) {
          {
            double score = self.positiveScore;

            stream.nativeStream.print("score=" + score);
            if ((weight != Stella.NULL_FLOAT) && (!(weight == 1.0))) {
              stream.nativeStream.print(" weight=" + weight);
            }
          }
        } else {
        }
      }
    }
  }
  public void clearFramePartialTruth() {
    {
      PartialMatchFrame self = this;

      self.positiveScore = Stella.NULL_FLOAT;
      self.negativeScore = Stella.NULL_FLOAT;
    }
  }
  public void setDynamicCutoff() {
    {
      PartialMatchFrame self = this;

      {
        double cutoff = self.computeDynamicCutoff();

        if (cutoff != Stella.NULL_FLOAT) {
          if ((cutoff < -100) || (cutoff > 100)) {
            Stella.STANDARD_WARNING.nativeStream.println(
                "Warning: *** fishy dynamic cutoff=`" + cutoff + "' computed, resetting to 0.0");
            cutoff = 0.0;
          }
          self.dynamicCutoff = cutoff;
        }
      }
    }
  }
  public void initializePartialMatchStrategy(QueryIterator query) {
    {
      PartialMatchFrame self = this;

      {
        FloatWrapper minimumscore =
            ((FloatWrapper) (query.options.lookup(Logic.KWD_MINIMUM_SCORE)));
        double epsilon = 0.001;

        query.partialMatchStrategy = self;
        self.dynamicCutoff = ((minimumscore != null) ? minimumscore.wrapperValue : epsilon);
        KeyValueList.setDynamicSlotValue(
            query.dynamicSlots,
            Logic.SYM_LOGIC_LATEST_POSITIVE_SCORE,
            FloatWrapper.wrapFloat(0.0),
            Stella.NULL_FLOAT_WRAPPER);
      }
    }
  }
  public static void linkToParentPartialMatchFrame(PartialMatchFrame self) {
    {
      ControlFrame controlframe = self.controlFrame.up;

      while ((controlframe != null) && (controlframe.partialMatchFrame == null)) {
        controlframe = controlframe.up;
      }
      if (controlframe != null) {
        self.parent = controlframe.partialMatchFrame;
        controlframe.partialMatchFrame.child = self;
      }
    }
  }
  public PartialMatchFrame createPartialMatchFrame(ControlFrame frame, Keyword kind) {
    {
      PartialMatchFrame self = this;

      {
        frame = frame;
        kind = kind;
      }
      {
        OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

        {
          stream000.nativeStream.println(
              "Missing concrete method named 'create-partial-match-frame' on the");
          stream000.nativeStream.print("   class `" + self.primaryType() + "'");
        }
        ;
        throw ((StellaException)
            (StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
      }
    }
  }
  public void propagateFramePartialTruth(ControlFrame target) {
    {
      PartialMatchFrame source = this;

      {
        PartialMatchFrame targetpmf = target.partialMatchFrame;
        boolean flippolarityP = !(source.controlFrame.reversePolarityP == target.reversePolarityP);

        if (targetpmf == null) {
          if (flippolarityP) {
            targetpmf =
                ((PartialMatchFrame)
                    (Surrogate.createObject(
                        source.primaryType(),
                        Stella_Object.cons(
                            Logic.KWD_CONTROL_FRAME,
                            Stella_Object.cons(
                                target,
                                Stella_Object.cons(
                                    Logic.KWD_KIND,
                                    Stella_Object.cons(target.state, Stella.NIL)))))));
            targetpmf.parent = source.parent;
            targetpmf.child = source;
          } else {
            targetpmf = source;
          }
          target.partialMatchFrame = targetpmf;
        }
        if (flippolarityP) {
          targetpmf.positiveScore = 0 - source.positiveScore;
          targetpmf.negativeScore = source.positiveScore;
        } else {
          targetpmf.positiveScore = source.positiveScore;
          targetpmf.negativeScore = source.negativeScore;
        }
        KeyValueList.setDynamicSlotValue(
            ((QueryIterator) (Logic.$QUERYITERATOR$.get())).dynamicSlots,
            Logic.SYM_LOGIC_LATEST_POSITIVE_SCORE,
            FloatWrapper.wrapFloat(targetpmf.positiveScore),
            Stella.NULL_FLOAT_WRAPPER);
      }
    }
  }
  public static Stella_Object accessPartialMatchFrameSlotValue(
      PartialMatchFrame self, Symbol slotname, Stella_Object value, boolean setvalueP) {
    if (slotname == Logic.SYM_LOGIC_KIND) {
      if (setvalueP) {
        self.kind = ((Keyword) (value));
      } else {
        value = self.kind;
      }
    } else if (slotname == Logic.SYM_LOGIC_CONTROL_FRAME) {
      if (setvalueP) {
        self.controlFrame = ((ControlFrame) (value));
      } else {
        value = self.controlFrame;
      }
    } else if (slotname == Logic.SYM_LOGIC_PARENT) {
      if (setvalueP) {
        self.parent = ((PartialMatchFrame) (value));
      } else {
        value = self.parent;
      }
    } else if (slotname == Logic.SYM_LOGIC_CHILD) {
      if (setvalueP) {
        self.child = ((PartialMatchFrame) (value));
      } else {
        value = self.child;
      }
    } else if (slotname == Logic.SYM_LOGIC_POSITIVE_SCORE) {
      if (setvalueP) {
        self.positiveScore = ((FloatWrapper) (value)).wrapperValue;
      } else {
        value = FloatWrapper.wrapFloat(self.positiveScore);
      }
    } else if (slotname == Logic.SYM_LOGIC_NEGATIVE_SCORE) {
      if (setvalueP) {
        self.negativeScore = ((FloatWrapper) (value)).wrapperValue;
      } else {
        value = FloatWrapper.wrapFloat(self.negativeScore);
      }
    } else if (slotname == Logic.SYM_LOGIC_DYNAMIC_CUTOFF) {
      if (setvalueP) {
        self.dynamicCutoff = ((FloatWrapper) (value)).wrapperValue;
      } else {
        value = FloatWrapper.wrapFloat(self.dynamicCutoff);
      }
    } else if (slotname == Logic.SYM_LOGIC_ARGUMENT_SCORES) {
      if (setvalueP) {
        self.argumentScores = ((Cons) (value));
      } else {
        value = self.argumentScores;
      }
    } else if (slotname == Logic.SYM_LOGIC_ARGUMENT_WEIGHTS) {
      if (setvalueP) {
        self.argumentWeights = ((Cons) (value));
      } else {
        value = self.argumentWeights;
      }
    } else if (slotname == Logic.SYM_LOGIC_UNBOUND_VARS) {
      if (setvalueP) {
        self.unboundVars = ((Cons) (value));
      } else {
        value = self.unboundVars;
      }
    } else if (slotname == Logic.SYM_LOGIC_SUCCESSp) {
      if (setvalueP) {
        self.successP = BooleanWrapper.coerceWrappedBooleanToBoolean(((BooleanWrapper) (value)));
      } else {
        value = (self.successP ? Stella.TRUE_WRAPPER : Stella.FALSE_WRAPPER);
      }
    } else {
      {
        OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

        stream000.nativeStream.print("`" + slotname + "' is not a valid case option");
        throw ((StellaException)
            (StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
      }
    }
    return (value);
  }