Class HardMediumSoftLongScore

java.lang.Object
org.optaplanner.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore
All Implemented Interfaces:
Serializable, Comparable<HardMediumSoftLongScore>, Score<HardMediumSoftLongScore>

public final class HardMediumSoftLongScore extends Object implements Score<HardMediumSoftLongScore>
This Score is based on 3 levels of long constraints: hard, medium and soft. Hard constraints have priority over medium constraints. Medium constraints have priority over soft constraints. Hard constraints determine feasibility.

This class is immutable.

See Also:
  • Field Details

  • Method Details

    • parseScore

      public static HardMediumSoftLongScore parseScore(String scoreString)
    • ofUninitialized

      public static HardMediumSoftLongScore ofUninitialized(int initScore, long hardScore, long mediumScore, long softScore)
    • of

      public static HardMediumSoftLongScore of(long hardScore, long mediumScore, long softScore)
    • ofHard

      public static HardMediumSoftLongScore ofHard(long hardScore)
    • ofMedium

      public static HardMediumSoftLongScore ofMedium(long mediumScore)
    • ofSoft

      public static HardMediumSoftLongScore ofSoft(long softScore)
    • initScore

      public int initScore()
      Description copied from interface: Score
      The init score is the negative of the number of uninitialized genuine planning variables. If it's 0 (which it usually is), the PlanningSolution is fully initialized and the score's Object.toString() does not mention it.

      During Comparable.compareTo(Object), it's even more important than the hard score: if you don't want this behaviour, read about overconstrained planning in the reference manual.

      Specified by:
      initScore in interface Score<HardMediumSoftLongScore>
      Returns:
      higher is better, always negative (except in statistical calculations), 0 if all planning variables are initialized
    • hardScore

      public long hardScore()
      The total of the broken negative hard constraints and fulfilled positive hard constraints. Their weight is included in the total. The hard score is usually a negative number because most use cases only have negative constraints.
      Returns:
      higher is better, usually negative, 0 if no hard constraints are broken/fulfilled
    • getHardScore

      @Deprecated(forRemoval=true) public long getHardScore()
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use hardScore() instead.
      As defined by hardScore().
    • mediumScore

      public long mediumScore()
      The total of the broken negative medium constraints and fulfilled positive medium constraints. Their weight is included in the total. The medium score is usually a negative number because most use cases only have negative constraints.

      In a normal score comparison, the medium score is irrelevant if the 2 scores don't have the same hard score.

      Returns:
      higher is better, usually negative, 0 if no medium constraints are broken/fulfilled
    • getMediumScore

      @Deprecated(forRemoval=true) public long getMediumScore()
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use mediumScore() instead.
      As defined by mediumScore().
    • softScore

      public long softScore()
      The total of the broken negative soft constraints and fulfilled positive soft constraints. Their weight is included in the total. The soft score is usually a negative number because most use cases only have negative constraints.

      In a normal score comparison, the soft score is irrelevant if the 2 scores don't have the same hard and medium score.

      Returns:
      higher is better, usually negative, 0 if no soft constraints are broken/fulfilled
    • getSoftScore

      @Deprecated(forRemoval=true) public long getSoftScore()
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use softScore() instead.
      As defined by softScore().
    • withInitScore

      public HardMediumSoftLongScore withInitScore(int newInitScore)
      Description copied from interface: Score
      For example 0hard/-8soft with -7 returns -7init/0hard/-8soft.
      Specified by:
      withInitScore in interface Score<HardMediumSoftLongScore>
      Parameters:
      newInitScore - always negative (except in statistical calculations), 0 if all planning variables are initialized
      Returns:
      equals score except that Score.initScore() is set to newInitScore
    • isFeasible

      public boolean isFeasible()
      A PlanningSolution is feasible if it has no broken hard constraints.
      Specified by:
      isFeasible in interface Score<HardMediumSoftLongScore>
      Returns:
      true if the hardScore() is 0 or higher
    • add

      Description copied from interface: Score
      Returns a Score whose value is (this + addend).
      Specified by:
      add in interface Score<HardMediumSoftLongScore>
      Parameters:
      addend - value to be added to this Score
      Returns:
      this + addend
    • subtract

      public HardMediumSoftLongScore subtract(HardMediumSoftLongScore subtrahend)
      Description copied from interface: Score
      Returns a Score whose value is (this - subtrahend).
      Specified by:
      subtract in interface Score<HardMediumSoftLongScore>
      Parameters:
      subtrahend - value to be subtracted from this Score
      Returns:
      this - subtrahend, rounded as necessary
    • multiply

      public HardMediumSoftLongScore multiply(double multiplicand)
      Description copied from interface: Score
      Returns a Score whose value is (this * multiplicand). When rounding is needed, it should be floored (as defined by Math.floor(double)).

      If the implementation has a scale/precision, then the unspecified scale/precision of the double multiplicand should have no impact on the returned scale/precision.

      Specified by:
      multiply in interface Score<HardMediumSoftLongScore>
      Parameters:
      multiplicand - value to be multiplied by this Score.
      Returns:
      this * multiplicand
    • divide

      public HardMediumSoftLongScore divide(double divisor)
      Description copied from interface: Score
      Returns a Score whose value is (this / divisor). When rounding is needed, it should be floored (as defined by Math.floor(double)).

      If the implementation has a scale/precision, then the unspecified scale/precision of the double divisor should have no impact on the returned scale/precision.

      Specified by:
      divide in interface Score<HardMediumSoftLongScore>
      Parameters:
      divisor - value by which this Score is to be divided
      Returns:
      this / divisor
    • power

      public HardMediumSoftLongScore power(double exponent)
      Description copied from interface: Score
      Returns a Score whose value is (this ^ exponent). When rounding is needed, it should be floored (as defined by Math.floor(double)).

      If the implementation has a scale/precision, then the unspecified scale/precision of the double exponent should have no impact on the returned scale/precision.

      Specified by:
      power in interface Score<HardMediumSoftLongScore>
      Parameters:
      exponent - value by which this Score is to be powered
      Returns:
      this ^ exponent
    • abs

      Description copied from interface: Score
      Returns a Score whose value is the absolute value of the score, i.e. |this|.
      Specified by:
      abs in interface Score<HardMediumSoftLongScore>
      Returns:
      never null
    • zero

      public HardMediumSoftLongScore zero()
      Description copied from interface: Score
      Returns a Score, all levels of which are zero.
      Specified by:
      zero in interface Score<HardMediumSoftLongScore>
      Returns:
      never null
    • toLevelNumbers

      public Number[] toLevelNumbers()
      Description copied from interface: Score
      Returns an array of numbers representing the Score. Each number represents 1 score level. A greater score level uses a lower array index than a lesser score level.

      When rounding is needed, each rounding should be floored (as defined by Math.floor(double)). The length of the returned array must be stable for a specific Score implementation.

      For example: -0hard/-7soft returns new int{-0, -7}

      The level numbers do not contain the Score.initScore(). For example: -3init/-0hard/-7soft also returns new int{-0, -7}

      Specified by:
      toLevelNumbers in interface Score<HardMediumSoftLongScore>
      Returns:
      never null
    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object
    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object
    • compareTo

      public int compareTo(HardMediumSoftLongScore other)
      Specified by:
      compareTo in interface Comparable<HardMediumSoftLongScore>
    • toShortString

      public String toShortString()
      Description copied from interface: Score
      Like Object.toString(), but trims score levels which have a zero weight. For example 0hard/-258soft returns -258soft.

      Do not use this format to persist information as text, use Object.toString() instead, so it can be parsed reliably.

      Specified by:
      toShortString in interface Score<HardMediumSoftLongScore>
      Returns:
      never null
    • toString

      public String toString()
      Overrides:
      toString in class Object