o

# NegZFiniteDouble

### Companion class NegZFiniteDouble

#### objectNegZFiniteDouble

The companion object for `NegZFiniteDouble` that offers factory methods that produce `NegZFiniteDouble`s, implicit widening conversions from `NegZFiniteDouble` to other numeric types, and maximum and minimum constant values for `NegZFiniteDouble`.

Source
NegZFiniteDouble.scala
Linear Supertypes
AnyRef, Any
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. NegZFiniteDouble
2. AnyRef
3. Any
1. Hide All
2. Show All
Visibility
1. Public
2. Protected

### Value Members

1. final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
2. final def ##: Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
4. final val MaxValue

The largest value representable as a finite non-positive `Double`, which is `NegZFiniteDouble(0.0)`.

5. final val MinValue

The smallest value representable as a finite non-positive `Double`, which is `NegZFiniteDouble(-1.7976931348623157E308)`.

6. implicit macro def apply(value: Double)

A factory method, implemented via a macro, that produces a `NegZFiniteDouble` if passed a valid `Double` literal, otherwise a compile time error.

A factory method, implemented via a macro, that produces a `NegZFiniteDouble` if passed a valid `Double` literal, otherwise a compile time error.

The macro that implements this method will inspect the specified `Double` expression at compile time. If the expression is a finite non-positive `Double` literal, it will return a `NegZFiniteDouble` representing that value. Otherwise, the passed `Double` expression is either a literal that is not finite non-positive, or is not a literal, so this method will give a compiler error.

This factory method differs from the `from` factory method in that this method is implemented via a macro that inspects `Double` literals at compile time, whereas `from` inspects `Double` values at run time.

value

the `Double` literal expression to inspect at compile time, and if finite non-positive, to return wrapped in a `NegZFiniteDouble` at run time.

returns

the specified, valid `Double` literal value wrapped in a `NegZFiniteDouble`. (If the specified expression is not a valid `Double` literal, the invocation of this method will not compile.)

7. final def asInstanceOf[T0]: T0
Definition Classes
Any
8. def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
9. def ensuringValid(value: Double)

A factory/assertion method that produces a `NegZFiniteDouble` given a valid `Double` value, or throws `AssertionError`, if given an invalid `Double` value.

A factory/assertion method that produces a `NegZFiniteDouble` given a valid `Double` value, or throws `AssertionError`, if given an invalid `Double` value.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `NegZFiniteDouble` representing that value. Otherwise, the passed `Double` value is not finite non-positive, so this method will throw `AssertionError`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas `from` inspects `Double` values at run time. It differs from a vanilla `assert` or `ensuring` call in that you get something you didn't already have if the assertion succeeds: a type that promises a `Double` is finite non-positive.

value

the `Double` to inspect, and if finite non-positive, return wrapped in a `NegZFiniteDouble`.

returns

the specified `Double` value wrapped in a `NegZFiniteDouble`, if it is finite non-positive, else throws `AssertionError`.

Exceptions thrown

`AssertionError` if the passed value is not finite non-positive

10. final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
11. def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
12. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
13. def from(value: Double): Option[NegZFiniteDouble]

A factory method that produces an `Option[NegZFiniteDouble]` given a `Double` value.

A factory method that produces an `Option[NegZFiniteDouble]` given a `Double` value.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `NegZFiniteDouble` representing that value, wrapped in a `Some`. Otherwise, the passed `Double` value is not finite non-positive, so this method will return `None`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas `from` inspects `Double` values at run time.

value

the `Double` to inspect, and if finite non-positive, return wrapped in a `Some[NegZFiniteDouble]`.

returns

the specified `Double` value wrapped in a `Some[NegZFiniteDouble]`, if it is NegZFiniteDouble, else `None`.

14. def fromOrElse(value: Double, default: => NegZFiniteDouble)

A factory method that produces a `NegZFiniteDouble` given a `Double` value and a default `NegZFiniteDouble`.

A factory method that produces a `NegZFiniteDouble` given a `Double` value and a default `NegZFiniteDouble`.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `NegZFiniteDouble` representing that value. Otherwise, the passed `Double` value is finite non-positive, so this method will return the passed `default` value.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas `from` inspects `Double` values at run time.

value

the `Double` to inspect, and if finite non-positive, return.

default

the `NegZFiniteDouble` to return if the passed `Double` value is not finite non-positive.

returns

the specified `Double` value wrapped in a `NegZFiniteDouble`, if it is finite non-positive, else the `default` `NegZFiniteDouble` value.

15. final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
16. def goodOrElse[B](value: Double)(f: (Double) => B): Or[NegZFiniteDouble, B]

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Good`, given a valid `Double` value, or if the given `Double` is invalid, an error value of type `B` produced by passing the given invalid `Double` value to the given function `f`, wrapped in a `Bad`.

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Good`, given a valid `Double` value, or if the given `Double` is invalid, an error value of type `B` produced by passing the given invalid `Double` value to the given function `f`, wrapped in a `Bad`.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `NegZFiniteDouble` representing that value, wrapped in a `Good`. Otherwise, the passed `Double` value is not finite non-positive, so this method will return a result of type `B` obtained by passing the invalid `Double` value to the given function `f`, wrapped in a `Bad`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas this method inspects `Double` values at run time.

value

the `Double` to inspect, and if finite non-positive, return wrapped in a `Good(NegZFiniteDouble)`.

returns

the specified `Double` value wrapped in a `Good(NegZFiniteDouble)`, if it is finite non-positive, else a `Bad(f(value))`.

17. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
18. final def isInstanceOf[T0]: Boolean
Definition Classes
Any
19. def isValid(value: Double): Boolean

A predicate method that returns true if a given `Double` value is finite non-positive.

A predicate method that returns true if a given `Double` value is finite non-positive.

value

the `Double` to inspect, and if finite non-positive, return true.

returns

true if the specified `Double` is positive, else false.

20. final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
21. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
22. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
23. implicit val ordering: Ordering[NegZFiniteDouble]

Implicit Ordering instance.

24. def passOrElse[E](value: Double)(f: (Double) => E): Validation[E]

A validation method that produces a `Pass` given a valid `Double` value, or an error value of type `E` produced by passing the given invalid `Int` value to the given function `f`, wrapped in a `Fail`.

A validation method that produces a `Pass` given a valid `Double` value, or an error value of type `E` produced by passing the given invalid `Int` value to the given function `f`, wrapped in a `Fail`.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `Pass`. Otherwise, the passed `Double` value is finite non-positive, so this method will return a result of type `E` obtained by passing the invalid `Double` value to the given function `f`, wrapped in a `Fail`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas this method inspects `Double` values at run time.

value

the `Int` to validate that it is finite non-positive.

returns

a `Pass` if the specified `Int` value is finite non-positive, else a `Fail` containing an error value produced by passing the specified `Double` to the given function `f`.

25. def rightOrElse[L](value: Double)(f: (Double) => L): Either[L, NegZFiniteDouble]

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Right`, given a valid `Double` value, or if the given `Double` is invalid, an error value of type `L` produced by passing the given invalid `Double` value to the given function `f`, wrapped in a `Left`.

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Right`, given a valid `Double` value, or if the given `Double` is invalid, an error value of type `L` produced by passing the given invalid `Double` value to the given function `f`, wrapped in a `Left`.

This method will inspect the passed `Double` value and if it is a finite non-positive `Double`, it will return a `NegZFiniteDouble` representing that value, wrapped in a `Right`. Otherwise, the passed `Double` value is not finite non-positive, so this method will return a result of type `L` obtained by passing the invalid `Double` value to the given function `f`, wrapped in a `Left`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Double` literals at compile time, whereas this method inspects `Double` values at run time.

value

the `Double` to inspect, and if finite non-positive, return wrapped in a `Right(NegZFiniteDouble)`.

returns

the specified `Double` value wrapped in a `Right(NegZFiniteDouble)`, if it is finite non-positive, else a `Left(f(value))`.

26. final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
27. def toString()
Definition Classes
AnyRef → Any
28. def tryingValid(value: Double): Try[NegZFiniteDouble]

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Success`, given a valid `Float` value, or if the given `Float` is invalid, an `AssertionError`, wrapped in a `Failure`.

A factory/validation method that produces a `NegZFiniteDouble`, wrapped in a `Success`, given a valid `Float` value, or if the given `Float` is invalid, an `AssertionError`, wrapped in a `Failure`.

Note: you should use this method only when you are convinced that it will always succeed, i.e., never throw an exception. It is good practice to add a comment near the invocation of this method indicating why you think it will always succeed to document your reasoning. If you are not sure an `ensuringValid` call will always succeed, you should use one of the other factory or validation methods provided on this object instead: `isValid`, `tryingValid`, `passOrElse`, `goodOrElse`, or `rightOrElse`.

This method will inspect the passed `Float` value and if it is a finite non-positive `Float`, it will return a `NegZFiniteDouble` representing that value, wrapped in a `Success`. Otherwise, the passed `Float` value is not finite non-positive, so this method will return an `AssertionError`, wrapped in a `Failure`.

This factory method differs from the `apply` factory method in that `apply` is implemented via a macro that inspects `Float` literals at compile time, whereas this method inspects `Float` values at run time.

value

the `Float` to inspect, and if finite non-positive, return wrapped in a `Success(NegZFiniteDouble)`.

returns

the specified `Float` value wrapped in a `Success(NegZFiniteDouble)`, if it is finite non-positive, else a `Failure(AssertionError)`.

29. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
30. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
31. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
32. implicit def widenToDouble(pos: NegZFiniteDouble): Double

Implicit widening conversion from `NegZFiniteDouble` to `Double`.

Implicit widening conversion from `NegZFiniteDouble` to `Double`.

pos

the `NegZFiniteDouble` to widen

returns

the `Double` value underlying the specified `NegZFiniteDouble`

33. implicit def widenToNegZDouble(pos: NegZFiniteDouble)

Implicit widening conversion from `NegZFiniteDouble` to `NegZDouble`.

Implicit widening conversion from `NegZFiniteDouble` to `NegZDouble`.

pos

the `NegZFiniteDouble` to widen

returns

the `Double` value underlying the specified `NegZFiniteDouble`, widened to `Double` and wrapped in a `NegZDouble`.