java.lang.Object
- ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore

All Implemented Interfaces:

Score<HardSoftBigDecimalScore>, Serializable, Comparable<HardSoftBigDecimalScore>
```
public final class HardSoftBigDecimalScore
extends Object
implements Score<HardSoftBigDecimalScore>
```
This Score is based on 2 levels of BigDecimal constraints: hard and soft. Hard 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 Description

static HardSoftBigDecimalScore ONE_HARD

static HardSoftBigDecimalScore ONE_SOFT

static HardSoftBigDecimalScore ZERO

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`HardSoftBigDecimalScore`	`abs()`	Returns a Score whose value is the absolute value of the score, i.e.
`HardSoftBigDecimalScore`	`add(HardSoftBigDecimalScore addend)`	Returns a Score whose value is (this + addend).
`int`	`compareTo(HardSoftBigDecimalScore other)`
`HardSoftBigDecimalScore`	`divide(double divisor)`	Returns a Score whose value is (this / divisor).
`boolean`	`equals(Object o)`
`BigDecimal`	`getHardScore()`	Deprecated, for removal: This API element is subject to removal in a future version. Use `hardScore()` instead.
`BigDecimal`	`getSoftScore()`	Deprecated, for removal: This API element is subject to removal in a future version. Use `softScore()` instead.
`BigDecimal`	`hardScore()`	The total of the broken negative hard constraints and fulfilled positive hard constraints.
`int`	`hashCode()`
`int`	`initScore()`	The init score is the negative of the number of uninitialized genuine planning variables.
`boolean`	`isFeasible()`	A `PlanningSolution` is feasible if it has no broken hard constraints and `Score.isSolutionInitialized()` is true.
`HardSoftBigDecimalScore`	`multiply(double multiplicand)`	Returns a Score whose value is (this * multiplicand).
`static HardSoftBigDecimalScore`	`of(BigDecimal hardScore, BigDecimal softScore)`
`static HardSoftBigDecimalScore`	`ofHard(BigDecimal hardScore)`
`static HardSoftBigDecimalScore`	`ofSoft(BigDecimal softScore)`
`static HardSoftBigDecimalScore`	`ofUninitialized(int initScore, BigDecimal hardScore, BigDecimal softScore)`
`static HardSoftBigDecimalScore`	`parseScore(String scoreString)`
`HardSoftBigDecimalScore`	`power(double exponent)`	Returns a Score whose value is (this ^ exponent).
`BigDecimal`	`softScore()`	The total of the broken negative soft constraints and fulfilled positive soft constraints.
`HardSoftBigDecimalScore`	`subtract(HardSoftBigDecimalScore 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()`
`HardSoftBigDecimalScore`	`withInitScore(int newInitScore)`	For example `0hard/-8soft` with `-7` returns `-7init/0hard/-8soft`.
`HardSoftBigDecimalScore`	`zero()`	Returns a Score, all levels of which are zero.

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

Methods inherited from interface ai.timefold.solver.core.api.score.Score
getInitScore, isSolutionInitialized, isZero, negate, toLevelDoubles

- Field Detail
  - ZERO
```
public static final HardSoftBigDecimalScore ZERO
```
  - ONE_HARD
```
public static final HardSoftBigDecimalScore ONE_HARD
```
  - ONE_SOFT
```
public static final HardSoftBigDecimalScore ONE_SOFT
```
- Method Detail
  - parseScore
```
public static HardSoftBigDecimalScore parseScore(String scoreString)
```
  - ofUninitialized
```
public static HardSoftBigDecimalScore ofUninitialized(int initScore,
                                                      BigDecimal hardScore,
                                                      BigDecimal softScore)
```
  - of
```
public static HardSoftBigDecimalScore of(BigDecimal hardScore,
                                         BigDecimal softScore)
```
  - ofHard
```
public static HardSoftBigDecimalScore ofHard(BigDecimal hardScore)
```
  - ofSoft
```
public static HardSoftBigDecimalScore ofSoft(BigDecimal softScore)
```
  - 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<HardSoftBigDecimalScore>
    
    Returns:
    
    higher is better, always negative (except in statistical calculations), 0 if all planning variables are initialized
  - hardScore
```
public BigDecimal 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 BigDecimal getHardScore()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    Use hardScore() instead.
    
    As defined by hardScore().
  - softScore
```
public BigDecimal 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 BigDecimal getSoftScore()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    Use softScore() instead.
    
    As defined by softScore().
  - withInitScore
```
public HardSoftBigDecimalScore withInitScore(int newInitScore)
```
    Description copied from interface: Score
    
    For example 0hard/-8soft with -7 returns -7init/0hard/-8soft.
    
    Specified by:
    
    withInitScore in interface Score<HardSoftBigDecimalScore>
    
    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
  - 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<HardSoftBigDecimalScore>
    
    Returns:
    
    true if the hard score is 0 or higher and the Score.initScore() is 0.
  - add
```
public HardSoftBigDecimalScore add(HardSoftBigDecimalScore addend)
```
    Description copied from interface: Score
    
    Returns a Score whose value is (this + addend).
    
    Specified by:
    
    add in interface Score<HardSoftBigDecimalScore>
    
    Parameters:
    
    addend - value to be added to this Score
    
    Returns:
    
    this + addend
  - subtract
```
public HardSoftBigDecimalScore subtract(HardSoftBigDecimalScore subtrahend)
```
    Description copied from interface: Score
    
    Returns a Score whose value is (this - subtrahend).
    
    Specified by:
    
    subtract in interface Score<HardSoftBigDecimalScore>
    
    Parameters:
    
    subtrahend - value to be subtracted from this Score
    
    Returns:
    
    this - subtrahend, rounded as necessary
  - multiply
```
public HardSoftBigDecimalScore 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<HardSoftBigDecimalScore>
    
    Parameters:
    
    multiplicand - value to be multiplied by this Score.
    
    Returns:
    
    this * multiplicand
  - divide
```
public HardSoftBigDecimalScore 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<HardSoftBigDecimalScore>
    
    Parameters:
    
    divisor - value by which this Score is to be divided
    
    Returns:
    
    this / divisor
  - power
```
public HardSoftBigDecimalScore 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<HardSoftBigDecimalScore>
    
    Parameters:
    
    exponent - value by which this Score is to be powered
    
    Returns:
    
    this ^ exponent
  - abs
```
public HardSoftBigDecimalScore 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<HardSoftBigDecimalScore>
    
    Returns:
    
    never null
  - zero
```
public HardSoftBigDecimalScore zero()
```
    Description copied from interface: Score
    
    Returns a Score, all levels of which are zero.
    
    Specified by:
    
    zero in interface Score<HardSoftBigDecimalScore>
    
    Returns:
    
    never null
  - 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<HardSoftBigDecimalScore>
    
    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(HardSoftBigDecimalScore other)
```
    Specified by:
    
    compareTo in interface Comparable<HardSoftBigDecimalScore>
  - 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<HardSoftBigDecimalScore>
    
    Returns:
    
    never null
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Modifier and Type	Field	Description
`static HardSoftBigDecimalScore`	`ONE_HARD`
`static HardSoftBigDecimalScore`	`ONE_SOFT`
`static HardSoftBigDecimalScore`	`ZERO`

Class HardSoftBigDecimalScore

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ai.timefold.solver.core.api.score.Score

Field Detail

ZERO

ONE_HARD

ONE_SOFT

Method Detail

parseScore

ofUninitialized

of

ofHard

ofSoft

initScore

hardScore

getHardScore

softScore

getSoftScore

withInitScore

isFeasible

add

subtract

multiply

divide

power

abs

zero

toLevelNumbers

equals

hashCode

compareTo

toShortString

toString