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

## org.optaplanner.core.api.score.buildin.simpledouble
Class SimpleDoubleScore

    java.lang.Object
      org.optaplanner.core.api.score.AbstractScore<SimpleDoubleScore>
          org.optaplanner.core.api.score.buildin.simpledouble.SimpleDoubleScore

All Implemented Interfaces:
  Serializable, Comparable<SimpleDoubleScore>, Score<SimpleDoubleScore>

    public final class SimpleDoubleScore

extends AbstractScore<SimpleDoubleScore>

This `Score` is based on 1 level of double constraints.

Warning: Summing 2 doubles can cause a rounding error, which can cause score corruption. For example, this prints false: `System.out.println((0.01 + 0.05) == (0.01 + 0.02 + 0.03));` Use `SimpleBigDecimalScore` to avoid such problems.

This class is immutable.

See Also:
  `Score`, Serialized Form

Method Summary
`SimpleDoubleScore` | `add(SimpleDoubleScore augment)` Returns a Score whose value is (this + augment).
`int` | `compareTo(SimpleDoubleScore other)`
`SimpleDoubleScore` | `divide(double divisor)` Returns a Score whose value is (this / divisor).
`boolean` | `equals(Object o)`
`double` | `getScore()` The total of the broken negative constraints and fulfilled positive hard constraints.
`int` | `hashCode()`
`SimpleDoubleScore` | `multiply(double multiplicand)` Returns a Score whose value is (this * multiplicand).
`static SimpleDoubleScore` | `parseScore(String scoreString)`
`SimpleDoubleScore` | `power(double exponent)` Returns a Score whose value is (this ^ exponent).
`SimpleDoubleScore` | `subtract(SimpleDoubleScore subtrahend)` Returns a Score whose value is (this - subtrahend).
`Number[]` | `toLevelNumbers()` Returns an array of doubles representing the Score.
`String` | `toString()`
`static SimpleDoubleScore` | `valueOf(double score)`

Methods inherited from class org.optaplanner.core.api.score.AbstractScore
`buildScorePattern, buildScorePattern, parseLevelStrings, parseLevelStrings`

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

Method Detail

### parseScore

    public static SimpleDoubleScore parseScore(String scoreString)

### valueOf

    public static SimpleDoubleScore valueOf(double score)

### getScore

    public double getScore()

  The total of the broken negative constraints and fulfilled positive hard constraints. Their weight is included in the total. The score is usually a negative number because most use cases only have negative constraints.

  Returns:
    higher is better, usually negative, 0 if no constraints are broken/fulfilled

### add

    public SimpleDoubleScore add(SimpleDoubleScore augment)

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

  Parameters:
    `augment` - value to be added to this Score
  Returns:
    this + augment

### subtract

    public SimpleDoubleScore subtract(SimpleDoubleScore subtrahend)

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

  Parameters:
    `subtrahend` - value to be subtracted from this Score
  Returns:
    this - subtrahend, rounded as necessary

### multiply

    public SimpleDoubleScore 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.

  Parameters:
    `multiplicand` - value to be multiplied by this Score.
  Returns:
    this * multiplicand

### divide

    public SimpleDoubleScore 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.

  Parameters:
    `divisor` - value by which this Score is to be divided
  Returns:
    this / divisor

### power

    public SimpleDoubleScore 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.

  Parameters:
    `exponent` - value by which this Score is to be powered
  Returns:
    this ^ exponent

### toLevelNumbers

    public Number[] toLevelNumbers()

  Description copied from interface: `Score`
  Returns an array of doubles representing the Score. Each double 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 double{-0.0, -7.0}

  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(SimpleDoubleScore other)

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

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

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