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

## Class BendableLongScore

- java.lang.Object
- - org.optaplanner.core.api.score.AbstractScore<S>
  - - org.optaplanner.core.api.score.AbstractBendableScore<BendableLongScore>
    - - org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore

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

      public final class BendableLongScore
      extends AbstractBendableScore<BendableLongScore>
      implements FeasibilityScore<BendableLongScore>

  This `Score` is based on n levels of long constraints. The number of levels is bendable at configuration time.

  This class is immutable.

  The `getHardLevelsSize()` and `getSoftLevelsSize()` must be the same as in the `BendableLongScoreDefinition` used.

  See Also:
    `Score`, Serialized Form

- - ### Field Summary

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

      `HARD_LABEL, LEVEL_SUFFIXES, SOFT_LABEL`

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

      `INIT_LABEL, initScore`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `BendableLongScore​(int initScore, long[] hardScores, long[] softScores)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `BendableLongScore` | `add​(BendableLongScore addend)` | Returns a Score whose value is (this + addend).
    `int` | `compareTo​(BendableLongScore other)` |
    `BendableLongScore` | `divide​(double divisor)` | Returns a Score whose value is (this / divisor).
    `boolean` | `equals​(Object o)` |
    `int` | `getHardLevelsSize()` | The sum of this and `AbstractBendableScore.getSoftLevelsSize()` equals `AbstractBendableScore.getLevelsSize()`.
    `long` | `getHardOrSoftScore​(int index)` |
    `long` | `getHardScore​(int index)` |
    `long[]` | `getHardScores()` |
    `int` | `getLevelsSize()` |
    `int` | `getSoftLevelsSize()` | The sum of `AbstractBendableScore.getHardLevelsSize()` and this equals `AbstractBendableScore.getLevelsSize()`.
    `long` | `getSoftScore​(int index)` |
    `long[]` | `getSoftScores()` |
    `int` | `hashCode()` |
    `boolean` | `isCompatibleArithmeticArgument​(Score otherScore)` |
    `boolean` | `isFeasible()` | A `PlanningSolution` is feasible if it has no broken hard constraints and `Score.isSolutionInitialized()` is true.
    `BendableLongScore` | `multiply​(double multiplicand)` | Returns a Score whose value is (this * multiplicand).
    `BendableLongScore` | `negate()` | Returns a Score whose value is (- this).
    `static BendableLongScore` | `of​(long[] hardScores, long[] softScores)` | Creates a new `BendableLongScore`.
    `static BendableLongScore` | `ofHard​(int hardLevelsSize, int softLevelsSize, int hardLevel, long hardScore)` | Creates a new `BendableLongScore`.
    `static BendableLongScore` | `ofSoft​(int hardLevelsSize, int softLevelsSize, int softLevel, long softScore)` | Creates a new `BendableLongScore`.
    `static BendableLongScore` | `ofUninitialized​(int initScore, long[] hardScores, long[] softScores)` | Creates a new `BendableLongScore`.
    `static BendableLongScore` | `parseScore​(String scoreString)` |
    `BendableLongScore` | `power​(double exponent)` | Returns a Score whose value is (this ^ exponent).
    `BendableLongScore` | `subtract​(BendableLongScore subtrahend)` | Returns a Score whose value is (this - subtrahend).
    `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()` |
    `void` | `validateCompatible​(BendableLongScore other)` |
    `static BendableLongScore` | `valueOf​(long[] hardScores, long[] softScores)` | Deprecated. in favor of `of(long[], long[])`
    `static BendableLongScore` | `valueOfUninitialized​(int initScore, long[] hardScores, long[] softScores)` | Deprecated. in favor of `ofUninitialized(int, long[], long[])`
    `BendableLongScore` | `withInitScore​(int newInitScore)` | For example `0hard/-8soft` with `-7` returns `-7init/0hard/-8soft`.
    `static BendableLongScore` | `zero​(int hardLevelsSize, int softLevelsSize)` | Creates a new `BendableLongScore`.

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

      `buildBendableShortString, parseBendableScoreTokens`

    - ### 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, toInitializedScore`

- - ### Constructor Detail

    - #### BendableLongScore

          protected BendableLongScore​(int initScore,
                                      long[] hardScores,
                                      long[] softScores)

      Parameters:
        `initScore` - see `Score.getInitScore()`
        `hardScores` - never null
        `softScores` - never null

  - ### Method Detail

    - #### parseScore

          public static BendableLongScore parseScore​(String scoreString)

      Parameters:
        `scoreString` - never null
      Returns:
        never null

    - #### ofUninitialized

          public static BendableLongScore ofUninitialized​(int initScore,
                                                          long[] hardScores,
                                                          long[] softScores)

      Creates a new `BendableLongScore`.
      Parameters:
        `initScore` - see `Score.getInitScore()`
        `hardScores` - never null, never change that array afterwards: it must be immutable
        `softScores` - never null, never change that array afterwards: it must be immutable
      Returns:
        never null

    - #### valueOfUninitialized

          @Deprecated
          public static BendableLongScore valueOfUninitialized​(int initScore,
                                                               long[] hardScores,
                                                               long[] softScores)

      Deprecated.
      in favor of `ofUninitialized(int, long[], long[])`

    - #### of

          public static BendableLongScore of​(long[] hardScores,
                                             long[] softScores)

      Creates a new `BendableLongScore`.
      Parameters:
        `hardScores` - never null, never change that array afterwards: it must be immutable
        `softScores` - never null, never change that array afterwards: it must be immutable
      Returns:
        never null

    - #### valueOf

          @Deprecated
          public static BendableLongScore valueOf​(long[] hardScores,
                                                  long[] softScores)

      Deprecated.
      in favor of `of(long[], long[])`

    - #### zero

          public static BendableLongScore zero​(int hardLevelsSize,
                                               int softLevelsSize)

      Creates a new `BendableLongScore`.
      Parameters:
        `hardLevelsSize` - at least 0
        `softLevelsSize` - at least 0
      Returns:
        never null

    - #### ofHard

          public static BendableLongScore ofHard​(int hardLevelsSize,
                                                 int softLevelsSize,
                                                 int hardLevel,
                                                 long hardScore)

      Creates a new `BendableLongScore`.
      Parameters:
        `hardLevelsSize` - at least 0
        `softLevelsSize` - at least 0
        `hardLevel` - at least 0, less than hardLevelsSize
        `hardScore` - any
      Returns:
        never null

    - #### ofSoft

          public static BendableLongScore ofSoft​(int hardLevelsSize,
                                                 int softLevelsSize,
                                                 int softLevel,
                                                 long softScore)

      Creates a new `BendableLongScore`.
      Parameters:
        `hardLevelsSize` - at least 0
        `softLevelsSize` - at least 0
        `softLevel` - at least 0, less than softLevelsSize
        `softScore` - any
      Returns:
        never null

    - #### getHardScores

          public long[] getHardScores()

      Returns:
        not null, array copy because this class is immutable

    - #### getSoftScores

          public long[] getSoftScores()

      Returns:
        not null, array copy because this class is immutable

    - #### getHardLevelsSize

          public int getHardLevelsSize()

      Description copied from class: `AbstractBendableScore`
      The sum of this and `AbstractBendableScore.getSoftLevelsSize()` equals `AbstractBendableScore.getLevelsSize()`.
      Specified by:
        `getHardLevelsSize` in class `AbstractBendableScore<BendableLongScore>`
      Returns:
        `>= 0` and `<` `AbstractBendableScore.getLevelsSize()`

    - #### getHardScore

          public long getHardScore​(int index)

      Parameters:
        `index` - `0 <= index <` `getHardLevelsSize()`
      Returns:
        higher is better

    - #### getSoftLevelsSize

          public int getSoftLevelsSize()

      Description copied from class: `AbstractBendableScore`
      The sum of `AbstractBendableScore.getHardLevelsSize()` and this equals `AbstractBendableScore.getLevelsSize()`.
      Specified by:
        `getSoftLevelsSize` in class `AbstractBendableScore<BendableLongScore>`
      Returns:
        `>= 0` and `<` `AbstractBendableScore.getLevelsSize()`

    - #### getSoftScore

          public long getSoftScore​(int index)

      Parameters:
        `index` - `0 <= index <` `getSoftLevelsSize()`
      Returns:
        higher is better

    - #### withInitScore

          public BendableLongScore withInitScore​(int newInitScore)

      Description copied from interface: `Score`
      For example `0hard/-8soft` with `-7` returns `-7init/0hard/-8soft`.
      Specified by:
        `withInitScore` in interface `Score<BendableLongScore>`
      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`

    - #### getLevelsSize

          public int getLevelsSize()

      Specified by:
        `getLevelsSize` in class `AbstractBendableScore<BendableLongScore>`
      Returns:
        `AbstractBendableScore.getHardLevelsSize()` + `AbstractBendableScore.getSoftLevelsSize()`

    - #### getHardOrSoftScore

          public long getHardOrSoftScore​(int index)

      Parameters:
        `index` - `0 <= index <` `getLevelsSize()`
      Returns:
        higher is better

    - #### isFeasible

          public boolean isFeasible()

      Description copied from interface: `FeasibilityScore`
      A `PlanningSolution` is feasible if it has no broken hard constraints and `Score.isSolutionInitialized()` is true.
      Specified by:
        `isFeasible` in interface `FeasibilityScore<BendableLongScore>`
      Specified by:
        `isFeasible` in interface `Score<BendableLongScore>`
      Returns:
        true if the hard score is 0 or higher and the `Score.getInitScore()` is 0.

    - #### add

          public BendableLongScore add​(BendableLongScore addend)

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

    - #### subtract

          public BendableLongScore subtract​(BendableLongScore subtrahend)

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

    - #### multiply

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

    - #### divide

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

    - #### power

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

    - #### negate

          public BendableLongScore negate()

      Description copied from interface: `Score`
      Returns a Score whose value is (- this).
      Specified by:
        `negate` in interface `Score<BendableLongScore>`
      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<BendableLongScore>`
      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​(BendableLongScore other)

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

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

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### validateCompatible

          public void validateCompatible​(BendableLongScore other)

    - #### isCompatibleArithmeticArgument

          public boolean isCompatibleArithmeticArgument​(Score otherScore)

      Specified by:
        `isCompatibleArithmeticArgument` in interface `Score<BendableLongScore>`
      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)`.