Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| OptaPlanner distribution 6.2.0.Beta3
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.optaplanner.core.api.score.buildin.bendablebigdecimal
Class BendableBigDecimalScore

    java.lang.Object
      org.optaplanner.core.api.score.AbstractScore<BendableBigDecimalScore>
          org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore

All Implemented Interfaces:
  Serializable, Comparable<BendableBigDecimalScore>, FeasibilityScore<BendableBigDecimalScore>, Score<BendableBigDecimalScore>

    public final class BendableBigDecimalScore

extends AbstractScore<BendableBigDecimalScore>
implements FeasibilityScore<BendableBigDecimalScore>

This `Score` is based on n levels of `BigDecimal` 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 `BendableScoreDefinition` used.

See Also:
  `Score`, Serialized Form

Constructor Summary
`protected` | `BendableBigDecimalScore(BigDecimal[] hardScores, BigDecimal[] softScores)`

Method Summary
`BendableBigDecimalScore` | `add(BendableBigDecimalScore augment)` Returns a Score whose value is (this + augment).
`int` | `compareTo(BendableBigDecimalScore other)`
`BendableBigDecimalScore` | `divide(double divisor)` Returns a Score whose value is (this / divisor).
`boolean` | `equals(Object o)`
`int` | `getHardLevelsSize()`
`BigDecimal` | `getHardScore(int index)`
`int` | `getSoftLevelsSize()`
`BigDecimal` | `getSoftScore(int index)`
`int` | `hashCode()`
`boolean` | `isCompatibleArithmeticArgument(Score otherScore)`
`boolean` | `isFeasible()` A `Solution` is feasible if it has no broken hard constraints.
`BendableBigDecimalScore` | `multiply(double multiplicand)` Returns a Score whose value is (this * multiplicand).
`BendableBigDecimalScore` | `negate()` Returns a Score whose value is (- this).
`static BendableBigDecimalScore` | `parseScore(int hardLevelsSize, int softLevelsSize, String scoreString)`
`BendableBigDecimalScore` | `power(double exponent)` Returns a Score whose value is (this ^ exponent).
`BendableBigDecimalScore` | `subtract(BendableBigDecimalScore subtrahend)` Returns a Score whose value is (this - subtrahend).
`Number[]` | `toLevelNumbers()` Returns an array of numbers representing the Score.
`String` | `toString()`
`void` | `validateCompatible(BendableBigDecimalScore other)`
`static BendableBigDecimalScore` | `valueOf(BigDecimal[] hardScores, BigDecimal[] softScores)` Creates a new `BendableBigDecimalScore`.

Methods inherited from class org.optaplanner.core.api.score.AbstractScore
`buildScorePattern, buildScorePattern, parseLevelAsBigDecimal, parseLevelAsDouble, parseLevelAsInt, parseLevelAsLong, parseLevelStrings, parseLevelStrings`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### BendableBigDecimalScore

    protected BendableBigDecimalScore(BigDecimal[] hardScores,
                                      BigDecimal[] softScores)

Method Detail

### parseScore

    public static BendableBigDecimalScore parseScore(int hardLevelsSize,
                                                     int softLevelsSize,
                                                     String scoreString)

### valueOf

    public static BendableBigDecimalScore valueOf(BigDecimal[] hardScores,
                                                  BigDecimal[] softScores)

  Creates a new `BendableBigDecimalScore`.

  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

### getHardLevelsSize

    public int getHardLevelsSize()

### getHardScore

    public BigDecimal getHardScore(int index)

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

### getSoftLevelsSize

    public int getSoftLevelsSize()

### getSoftScore

    public BigDecimal getSoftScore(int index)

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

### isFeasible

    public boolean isFeasible()

  Description copied from interface: `FeasibilityScore`
  A `Solution` is feasible if it has no broken hard constraints.

  Specified by:
    `isFeasible` in interface `FeasibilityScore<BendableBigDecimalScore>`
  Returns:
    true if the hard score(s) is 0 or higher

### add

    public BendableBigDecimalScore add(BendableBigDecimalScore augment)

  Description copied from interface: `Score`
  Returns a Score whose value is (this + augment).

  Specified by:
    `add` in interface `Score<BendableBigDecimalScore>`
  Parameters:
    `augment` - value to be added to this Score
  Returns:
    this + augment

### subtract

    public BendableBigDecimalScore subtract(BendableBigDecimalScore subtrahend)

  Description copied from interface: `Score`
  Returns a Score whose value is (this - subtrahend).

  Specified by:
    `subtract` in interface `Score<BendableBigDecimalScore>`
  Parameters:
    `subtrahend` - value to be subtracted from this Score
  Returns:
    this - subtrahend, rounded as necessary

### multiply

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

### divide

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

### power

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

### negate

    public BendableBigDecimalScore negate()

  Description copied from interface: `Score`
  Returns a Score whose value is (- this).

  Specified by:
    `negate` in interface `Score<BendableBigDecimalScore>`
  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}

  Specified by:
    `toLevelNumbers` in interface `Score<BendableBigDecimalScore>`
  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(BendableBigDecimalScore other)

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

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### validateCompatible

    public void validateCompatible(BendableBigDecimalScore other)

### isCompatibleArithmeticArgument

    public boolean isCompatibleArithmeticArgument(Score otherScore)

  Specified by:
    `isCompatibleArithmeticArgument` in interface `Score<BendableBigDecimalScore>`
  Overrides:
    `isCompatibleArithmeticArgument` in class `AbstractScore<BendableBigDecimalScore>`
  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)`.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| OptaPlanner distribution 6.2.0.Beta3
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2006-2014 JBoss by Red Hat. All Rights Reserved.