java.lang.Object
- ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore

All Implemented Interfaces:

Score<HardSoftLongScore>, Serializable, Comparable<HardSoftLongScore>
```
public final class HardSoftLongScore
extends Object
implements Score<HardSoftLongScore>
```
This Score is based on 2 levels of long 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 HardSoftLongScore ONE_HARD

static HardSoftLongScore ONE_SOFT

static HardSoftLongScore ZERO

Method Summary

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

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

Class HardSoftLongScore

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