org.optaplanner.core.api.score.buildin.hardmediumsoft

## Class HardMediumSoftScore

- java.lang.Object
- - org.optaplanner.core.api.score.AbstractScore<HardMediumSoftScore>
  - - org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore

- All Implemented Interfaces:
    Serializable, Comparable<HardMediumSoftScore>, FeasibilityScore<HardMediumSoftScore>, Score<HardMediumSoftScore>

      public final class HardMediumSoftScore
      extends AbstractScore<HardMediumSoftScore>
      implements FeasibilityScore<HardMediumSoftScore>

  This `Score` is based on 3 levels of int 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:
    `Score`, Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static HardMediumSoftScore` | `ONE_HARD`
    `static HardMediumSoftScore` | `ONE_MEDIUM`
    `static HardMediumSoftScore` | `ONE_SOFT`
    `static HardMediumSoftScore` | `ZERO`

    - ### Fields inherited from class org.optaplanner.core.api.score.AbstractScore

      `INIT_LABEL, initScore`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `HardMediumSoftScore` | `add(HardMediumSoftScore addend)` Returns a Score whose value is (this + addend).
    `int` | `compareTo(HardMediumSoftScore other)`
    `HardMediumSoftScore` | `divide(double divisor)` Returns a Score whose value is (this / divisor).
    `boolean` | `equals(Object o)`
    `int` | `getHardScore()` The total of the broken negative hard constraints and fulfilled positive hard constraints.
    `int` | `getMediumScore()` The total of the broken negative medium constraints and fulfilled positive medium constraints.
    `int` | `getSoftScore()` The total of the broken negative soft constraints and fulfilled positive soft constraints.
    `int` | `hashCode()`
    `boolean` | `isCompatibleArithmeticArgument(Score otherScore)`
    `boolean` | `isFeasible()` A `PlanningSolution` is feasible if it has no broken hard constraints.
    `HardMediumSoftScore` | `multiply(double multiplicand)` Returns a Score whose value is (this * multiplicand).
    `HardMediumSoftScore` | `negate()` Returns a Score whose value is (- this).
    `static HardMediumSoftScore` | `of(int hardScore, int mediumScore, int softScore)`
    `static HardMediumSoftScore` | `ofHard(int hardScore)`
    `static HardMediumSoftScore` | `ofMedium(int mediumScore)`
    `static HardMediumSoftScore` | `ofSoft(int softScore)`
    `static HardMediumSoftScore` | `ofUninitialized(int initScore, int hardScore, int mediumScore, int softScore)`
    `static HardMediumSoftScore` | `parseScore(String scoreString)`
    `HardMediumSoftScore` | `power(double exponent)` Returns a Score whose value is (this ^ exponent).
    `HardMediumSoftScore` | `subtract(HardMediumSoftScore subtrahend)` Returns a Score whose value is (this - subtrahend).
    `HardMediumSoftScore` | `toInitializedScore()` For example `-7init/0hard/-8soft` returns `0hard/-8soft`.
    `Number[]` | `toLevelNumbers()` Returns an array of numbers representing the Score.
    `String` | `toShortString()` Like `Object.toString()`, but trims score levels which have a zero weight.
    `String` | `toString()`
    `static HardMediumSoftScore` | `valueOf(int hardScore, int mediumScore, int softScore)` Deprecated. in favor of `of(int, int, int)`
    `static HardMediumSoftScore` | `valueOfUninitialized(int initScore, int hardScore, int mediumScore, int softScore)` Deprecated. in favor of `ofUninitialized(int, int, int, int)`
    `HardMediumSoftScore` | `withInitScore(int newInitScore)` For example `0hard/-8soft` with `-7` returns `-7init/0hard/-8soft`.

    - ### Methods inherited from class org.optaplanner.core.api.score.AbstractScore

      `assertNoInitScore, buildScorePattern, buildShortString, getInitPrefix, getInitScore, isSolutionInitialized, parseInitScore, parseLevelAsBigDecimal, parseLevelAsDouble, parseLevelAsInt, parseLevelAsLong, parseScoreTokens`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface org.optaplanner.core.api.score.Score

      `getInitScore, isSolutionInitialized`

- - ### Field Detail

    - #### ZERO

          public static final HardMediumSoftScore ZERO

    - #### ONE_HARD

          public static final HardMediumSoftScore ONE_HARD

    - #### ONE_MEDIUM

          public static final HardMediumSoftScore ONE_MEDIUM

    - #### ONE_SOFT

          public static final HardMediumSoftScore ONE_SOFT

  - ### Method Detail

    - #### parseScore

          public static HardMediumSoftScore parseScore(String scoreString)

    - #### ofUninitialized

          public static HardMediumSoftScore ofUninitialized(int initScore,
                                                            int hardScore,
                                                            int mediumScore,
                                                            int softScore)

    - #### valueOfUninitialized

          @Deprecated
          public static HardMediumSoftScore valueOfUninitialized(int initScore,
                                                                             int hardScore,
                                                                             int mediumScore,
                                                                             int softScore)

      Deprecated. in favor of `ofUninitialized(int, int, int, int)`

    - #### of

          public static HardMediumSoftScore of(int hardScore,
                                               int mediumScore,
                                               int softScore)

    - #### valueOf

          @Deprecated
          public static HardMediumSoftScore valueOf(int hardScore,
                                                                int mediumScore,
                                                                int softScore)

      Deprecated. in favor of `of(int, int, int)`

    - #### ofHard

          public static HardMediumSoftScore ofHard(int hardScore)

    - #### ofMedium

          public static HardMediumSoftScore ofMedium(int mediumScore)

    - #### ofSoft

          public static HardMediumSoftScore ofSoft(int softScore)

    - #### getHardScore

          public int getHardScore()

      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

    - #### getMediumScore

          public int getMediumScore()

      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

    - #### getSoftScore

          public int getSoftScore()

      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

    - #### toInitializedScore

          public HardMediumSoftScore toInitializedScore()

      Description copied from interface: `Score`
      For example `-7init/0hard/-8soft` returns `0hard/-8soft`.
      Specified by:
        `toInitializedScore` in interface `Score<HardMediumSoftScore>`
      Returns:
        equal score except that `Score.getInitScore()` is `0`.

    - #### withInitScore

          public HardMediumSoftScore withInitScore(int newInitScore)

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

    - #### isFeasible

          public boolean isFeasible()

      A `PlanningSolution` is feasible if it has no broken hard constraints.
      Specified by:
        `isFeasible` in interface `FeasibilityScore<HardMediumSoftScore>`
      Returns:
        true if the `getHardScore()` is 0 or higher

    - #### add

          public HardMediumSoftScore add(HardMediumSoftScore addend)

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

    - #### subtract

          public HardMediumSoftScore subtract(HardMediumSoftScore subtrahend)

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

    - #### multiply

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

    - #### divide

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

    - #### power

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

    - #### negate

          public HardMediumSoftScore negate()

      Description copied from interface: `Score`
      Returns a Score whose value is (- this).
      Specified by:
        `negate` in interface `Score<HardMediumSoftScore>`
      Returns:
        - this

    - #### 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.getInitScore()`. For example: `-3init/-0hard/-7soft` also returns `new int{-0, -7}`

      Specified by:
        `toLevelNumbers` in interface `Score<HardMediumSoftScore>`
      Returns:
        never null
      See Also:
        `ScoreDefinition.fromLevelNumbers(int, Number[])`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### compareTo

          public int compareTo(HardMediumSoftScore other)

      Specified by:
        `compareTo` in interface `Comparable<HardMediumSoftScore>`

    - #### 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<HardMediumSoftScore>`
      Returns:
        never null

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### isCompatibleArithmeticArgument

          public boolean isCompatibleArithmeticArgument(Score otherScore)

      Specified by:
        `isCompatibleArithmeticArgument` in interface `Score<HardMediumSoftScore>`
      Parameters:
        `otherScore` - never null
      Returns:
        true if the otherScore is accepted as a parameter of `Score.add(Score)`, `Score.subtract(Score)` and `Comparable.compareTo(Object)`.

Copyright © 2006–2020 JBoss by Red Hat. All rights reserved.