Package ai.timefold.solver.core.api.score.buildin.hardsoft

Class HardSoftScore

java.lang.Object
ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore
All Implemented Interfaces:
Score<HardSoftScore>, Serializable, Comparable<HardSoftScore>
@NullMarked public final class HardSoftScore extends Object implements Score<HardSoftScore>
This Score is based on 2 levels of int constraints: hard and soft. Hard constraints have priority over soft constraints. Hard constraints determine feasibility.

This class is immutable.

See Also:

  • Field Details

  • Method Details

    • parseScore

      public static HardSoftScore parseScore(String scoreString)

    • ofUninitialized

      @Deprecated(forRemoval=true, since="1.22.0") public static HardSoftScore ofUninitialized(int initScore, int hardScore, int softScore)
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use of(int, int) instead.
      Returns:
      init score is always zero

    • of

      public static HardSoftScore of(int hardScore, int softScore)

    • ofHard

      public static HardSoftScore ofHard(int hardScore)

    • ofSoft

      public static HardSoftScore ofSoft(int softScore)

    • hardScore

      public int 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 int getHardScore()
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use hardScore() instead.
      As defined by hardScore().

    • softScore

      public int 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 score.

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

    • getSoftScore

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

    • isFeasible

      public boolean isFeasible()
      Description copied from interface: Score
      A PlanningSolution is feasible if it has no broken hard constraints. Simple scores (SimpleScore, SimpleLongScore, SimpleBigDecimalScore) are always feasible.
      Specified by:
      isFeasible in interface Score<HardSoftScore>
      Returns:
      true if the hard score is 0 or higher.

    • add

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

    • subtract

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

    • multiply

      public HardSoftScore 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<HardSoftScore>
      Parameters:
      multiplicand - value to be multiplied by this Score.
      Returns:
      this * multiplicand

    • divide

      public HardSoftScore 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<HardSoftScore>
      Parameters:
      divisor - value by which this Score is to be divided
      Returns:
      this / divisor

    • power

      public HardSoftScore 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<HardSoftScore>
      Parameters:
      exponent - value by which this Score is to be powered
      Returns:
      this ^ exponent

    • abs

      public HardSoftScore 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<HardSoftScore>

    • zero

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

    • 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}

      Specified by:
      toLevelNumbers in interface Score<HardSoftScore>

    • equals

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

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • compareTo

      public int compareTo(HardSoftScore other)
      Specified by:
      compareTo in interface Comparable<HardSoftScore>

    • 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<HardSoftScore>

    • toString

      public String toString()
      Overrides:
      toString in class Object