Package org.optaplanner.core.api.score.buildin.simple

Class SimpleScore

java.lang.Object
org.optaplanner.core.api.score.buildin.simple.SimpleScore
All Implemented Interfaces:
Serializable, Comparable<SimpleScore>, Score<SimpleScore>
public final class SimpleScore extends Object implements Score<SimpleScore>
This Score is based on 1 level of int constraints.

This class is immutable.

See Also:

  • Field Details

  • Method Details

    • parseScore

      public static SimpleScore parseScore(String scoreString)

    • ofUninitialized

      public static SimpleScore ofUninitialized(int initScore, int score)

    • of

      public static SimpleScore of(int score)

    • 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<SimpleScore>
      Returns:
      higher is better, always negative (except in statistical calculations), 0 if all planning variables are initialized

    • score

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

    • getScore

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

    • withInitScore

      public SimpleScore withInitScore(int newInitScore)
      Description copied from interface: Score
      For example 0hard/-8soft with -7 returns -7init/0hard/-8soft.
      Specified by:
      withInitScore in interface Score<SimpleScore>
      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

    • add

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

    • subtract

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

    • multiply

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

    • divide

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

    • power

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

    • abs

      public SimpleScore 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<SimpleScore>
      Returns:
      never null

    • zero

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

    • isFeasible

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

    • 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<SimpleScore>
      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(SimpleScore other)
      Specified by:
      compareTo in interface Comparable<SimpleScore>

    • 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<SimpleScore>
      Returns:
      never null

    • toString

      public String toString()
      Overrides:
      toString in class Object