Scalactic 3.2.17/org.scalactic.anyvals/NonZeroFiniteDouble

NonZeroFiniteDouble

final class NonZeroFiniteDouble extends AnyVal

An AnyVal for finite non-zero Doubles.

Note: a NonZeroFiniteDouble may not equal 0.0.

Because NonZeroFiniteDouble is an AnyVal it will usually be as efficient as an Double, being boxed only when a Double would have been boxed.

The NonZeroFiniteDouble.apply factory method is implemented in terms of a macro that checks literals for validity at compile time. Calling NonZeroFiniteDouble.apply with a literal Double value will either produce a valid NonZeroFiniteDouble instance at run time or an error at compile time. Here's an example:

scala> import anyvals._
import anyvals._

scala> NonZeroFiniteDouble(1.1)
res1: org.scalactic.anyvals.NonZeroFiniteDouble = NonZeroFiniteDouble(1.1)

scala> NonZeroFiniteDouble(0.0)
<console>:14: error: NonZeroFiniteDouble.apply can only be invoked on a finite non-zero (i != 0.0 && !i.isNaN && i != Double.PositiveInfinity && i != Double.NegativeInfinity) floating point literal, like NonZeroFiniteDouble(1.1).
             NonZeroFiniteDouble(0.0)
                      ^

NonZeroFiniteDouble.apply cannot be used if the value being passed is a variable (i.e., not a literal), because the macro cannot determine the validity of variables at compile time (just literals). If you try to pass a variable to NonZeroFiniteDouble.apply, you'll get a compiler error that suggests you use a different factor method, NonZeroFiniteDouble.from, instead:

scala> val x = 1.1
x: Double = 1.1

scala> NonZeroFiniteDouble(x)
<console>:15: error: NonZeroFiniteDouble.apply can only be invoked on a floating point literal, like NonZeroFiniteDouble(1.1). Please use NonZeroFiniteDouble.from instead.
             NonZeroFiniteDouble(x)
                      ^

The NonZeroFiniteDouble.from factory method will inspect the value at runtime and return an Option[NonZeroFiniteDouble]. If the value is valid, NonZeroFiniteDouble.from will return a Some[NonZeroFiniteDouble], else it will return a None. Here's an example:

scala> NonZeroFiniteDouble.from(x)
res4: Option[org.scalactic.anyvals.NonZeroFiniteDouble] = Some(NonZeroFiniteDouble(1.1))

scala> val y = 0.0
y: Double = 0.0

scala> NonZeroFiniteDouble.from(y)
res5: Option[org.scalactic.anyvals.NonZeroFiniteDouble] = None

The NonZeroFiniteDouble.apply factory method is marked implicit, so that you can pass literal Doubles into methods that require NonZeroFiniteDouble, and get the same compile-time checking you get when calling NonZeroFiniteDouble.apply explicitly. Here's an example:

scala> def invert(pos: NonZeroFiniteDouble): Double = Double.MaxValue - pos
invert: (pos: org.scalactic.anyvals.NonZeroFiniteDouble)Double

scala> invert(1.1)
res6: Double = 1.7976931348623157E308

scala> invert(Double.MaxValue)
res8: Double = 0.0

scala> invert(0.0)
<console>:15: error: NonZeroFiniteDouble.apply can only be invoked on a finite non-zero (i != 0.0 && !i.isNaN && i != Double.PositiveInfinity && i != Double.NegativeInfinity) floating point literal, like NonZeroFiniteDouble(1.1).
             invert(0.0)
                    ^

This example also demonstrates that the NonZeroFiniteDouble companion object also defines implicit widening conversions when a similar conversion is provided in Scala. This makes it convenient to use a NonZeroFiniteDouble where a Double is needed. An example is the subtraction in the body of the invert method defined above, Double.MaxValue - pos. Although Double.MaxValue is a Double, which has no - method that takes a NonZeroFiniteDouble (the type of pos), you can still subtract pos, because the NonZeroFiniteDouble will be implicitly widened to Double.

Value parameters:

value: The Double value underlying this NonZeroFiniteDouble.

Companion:

object

Source:

NonZeroFiniteDouble.scala

class AnyVal

trait Matchable

class Any

NonZeroFiniteDouble

Value members

Concrete methods

Concrete fields