org.scalactic.anyvals.PosFiniteFloat.scala Maven / Gradle / Ivy
/*
* Copyright 2001-2016 Artima, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.scalactic.anyvals
import scala.collection.immutable.NumericRange
import scala.language.implicitConversions
import scala.util.{Try, Success, Failure}
import org.scalactic.{Validation, Pass, Fail}
import org.scalactic.{Or, Good, Bad}
/**
* An AnyVal for finite positive Floats.
*
*
* Note: a PosFiniteFloat may not equal 0.0. If you want positive number or 0, use [[PosZFiniteFloat]].
*
*
*
* Because PosFiniteFloat is an AnyVal it
* will usually be as efficient as an Float, being
* boxed only when an Float would have been boxed.
*
*
*
* The PosFiniteFloat.apply factory method is implemented
* in terms of a macro that checks literals for validity at
* compile time. Calling PosFiniteFloat.apply with a
* literal Float value will either produce a valid
* PosFiniteFloat instance at run time or an error at
* compile time. Here's an example:
*
*
*
* scala> import anyvals._
* import anyvals._
*
* scala> PosFiniteFloat(42.1fF)
* res0: org.scalactic.anyvals.PosFiniteFloat = PosFiniteFloat(42.1f)
*
* scala> PosFiniteFloat(0.0fF)
* <console>:14: error: PosFiniteFloat.apply can only be invoked on a finite positive (i > 0.0f && i != Float.PositiveInfinity) floating point literal, like PosFiniteFloat(42.1fF).
* PosFiniteFloat(42.1fF)
* ^
*
*
*
* PosFiniteFloat.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 PosFiniteFloat.apply, you'll get a compiler error
* that suggests you use a different factor method,
* PosFiniteFloat.from, instead:
*
*
*
* scala> val x = 42.1fF
* x: Float = 42.1f
*
* scala> PosFiniteFloat(x)
* <console>:15: error: PosFiniteFloat.apply can only be invoked on a floating point literal, like PosFiniteFloat(42.1fF). Please use PosFiniteFloat.from instead.
* PosFiniteFloat(x)
* ^
*
*
*
* The PosFiniteFloat.from factory method will inspect
* the value at runtime and return an
* Option[PosFiniteFloat]. If the value is valid,
* PosFiniteFloat.from will return a
* Some[PosFiniteFloat], else it will return a
* None. Here's an example:
*
*
*
* scala> PosFiniteFloat.from(x)
* res3: Option[org.scalactic.anyvals.PosFiniteFloat] = Some(PosFiniteFloat(42.1f))
*
* scala> val y = 0.0fF
* y: Float = 0.0f
*
* scala> PosFiniteFloat.from(y)
* res4: Option[org.scalactic.anyvals.PosFiniteFloat] = None
*
*
*
* The PosFiniteFloat.apply factory method is marked
* implicit, so that you can pass literal Floats
* into methods that require PosFiniteFloat, and get the
* same compile-time checking you get when calling
* PosFiniteFloat.apply explicitly. Here's an example:
*
*
*
* scala> def invert(pos: PosFiniteFloat): Float = Float.MaxValue - pos
* invert: (pos: org.scalactic.anyvals.PosFiniteFloat)Float
*
* scala> invert(42.1fF)
* res5: Float = 3.4028235E38
*
* scala> invert(Float.MaxValue)
* res6: Float = 0.0
*
* scala> invert(0.0fF)
* <console>:15: error: PosFiniteFloat.apply can only be invoked on a finite positive (i > 0.0f && i != Float.PositiveInfinity) floating point literal, like PosFiniteFloat(42.1fF).
* invert(0.0F)
* ^
*
* scala> invert(0.0fF)
* <console>:15: error: PosFiniteFloat.apply can only be invoked on a finite positive (i > 0.0f && i != Float.PositiveInfinity) floating point literal, like PosFiniteFloat(42.1fF).
* invert(0.0fF)
* ^
*
*
*
*
* This example also demonstrates that the PosFiniteFloat
* companion object also defines implicit widening conversions
* when no loss of precision will occur. This makes it convenient to use a
* PosFiniteFloat where a Float or wider
* type is needed. An example is the subtraction in the body of
* the invert method defined above,
* Float.MaxValue - pos. Although
* Float.MaxValue is a Float, which
* has no - method that takes a
* PosFiniteFloat (the type of pos), you can
* still subtract pos, because the
* PosFiniteFloat will be implicitly widened to
* Float.
*
*
* @param value The Float value underlying this PosFiniteFloat.
*/
final class PosFiniteFloat private (val value: Float) extends AnyVal {
/**
* A string representation of this PosFiniteFloat.
*/
override def toString: String = s"PosFiniteFloat(${value.toString()}f)"
/**
* Converts this PosFiniteFloat to a Byte.
*/
def toByte: Byte = value.toByte
/**
* Converts this PosFiniteFloat to a Short.
*/
def toShort: Short = value.toShort
/**
* Converts this PosFiniteFloat to a Char.
*/
def toChar: Char = value.toChar
/**
* Converts this PosFiniteFloat to an Int.
*/
def toInt: Int = value.toInt
/**
* Converts this PosFiniteFloat to a Long.
*/
def toLong: Long = value.toLong
/**
* Converts this PosFiniteFloat to a Float.
*/
def toFloat: Float = value.toFloat
/**
* Converts this PosFiniteFloat to a Double.
*/
def toDouble: Double = value.toDouble
/** Returns this value, unmodified. */
def unary_+ : PosFiniteFloat = this
/** Returns the negation of this value. */
def unary_- : NegFiniteFloat = NegFiniteFloat.ensuringValid(-value)
/**
* Converts this PosFiniteFloat's value to a string then concatenates the given string.
*/
def +(x: String): String = s"${value.toString()}${x.toString()}"
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Byte): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Short): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Char): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Int): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Long): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Float): Boolean = value < x
/** Returns `true` if this value is less than x, `false` otherwise. */
def <(x: Double): Boolean = value < x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Byte): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Short): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Char): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Int): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Long): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Float): Boolean = value <= x
/** Returns `true` if this value is less than or equal to x, `false` otherwise. */
def <=(x: Double): Boolean = value <= x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Byte): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Short): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Char): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Int): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Long): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Float): Boolean = value > x
/** Returns `true` if this value is greater than x, `false` otherwise. */
def >(x: Double): Boolean = value > x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Byte): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Short): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Char): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Int): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Long): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Float): Boolean = value >= x
/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
def >=(x: Double): Boolean = value >= x
/** Returns the sum of this value and `x`. */
def +(x: Byte): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Short): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Char): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Int): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Long): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Float): Float = value + x
/** Returns the sum of this value and `x`. */
def +(x: Double): Double = value + x
/** Returns the difference of this value and `x`. */
def -(x: Byte): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Short): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Char): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Int): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Long): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Float): Float = value - x
/** Returns the difference of this value and `x`. */
def -(x: Double): Double = value - x
/** Returns the product of this value and `x`. */
def *(x: Byte): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Short): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Char): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Int): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Long): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Float): Float = value * x
/** Returns the product of this value and `x`. */
def *(x: Double): Double = value * x
/** Returns the quotient of this value and `x`. */
def /(x: Byte): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Short): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Char): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Int): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Long): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Float): Float = value / x
/** Returns the quotient of this value and `x`. */
def /(x: Double): Double = value / x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Byte): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Short): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Char): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Int): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Long): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Float): Float = value % x
/** Returns the remainder of the division of this value by `x`. */
def %(x: Double): Double = value % x
// Stuff from RichFloat
/**
* Returns this if this > that or that otherwise.
*/
def max(that: PosFiniteFloat): PosFiniteFloat = if (math.max(value, that.value) == value) this else that
/**
* Returns this if this < that or that otherwise.
*/
def min(that: PosFiniteFloat): PosFiniteFloat = if (math.min(value, that.value) == value) this else that
/**
* Indicates whether this `PosFiniteFloat` has a value that is a whole number: it is finite and it has no fraction part.
*/
def isWhole = {
val longValue = value.toLong
longValue.toFloat == value || longValue == Long.MaxValue && value < Float.PositiveInfinity || longValue == Long.MinValue && value > Float.NegativeInfinity
}
/** Converts an angle measured in degrees to an approximately equivalent
* angle measured in radians.
*
* @return the measurement of the angle x in radians.
*/
def toRadians: Float = math.toRadians(value.toDouble).toFloat
/** Converts an angle measured in radians to an approximately equivalent
* angle measured in degrees.
* @return the measurement of the angle x in degrees.
*/
def toDegrees: Float = math.toDegrees(value.toDouble).toFloat
/**
* Applies the passed Float => Float function to the underlying Float
* value, and if the result is positive, returns the result wrapped in a PosFiniteFloat,
* else throws AssertionError.
*
*
* This method will inspect the result of applying the given function to this
* PosFiniteFloat's underlying Float value and if the result
* is finite positive, it will return a PosFiniteFloat representing that value.
* Otherwise, the Float value returned by the given function is
* not finite positive, so this method will throw AssertionError.
*
*
*
* This method 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 an Float is finite positive.
* With this method, you are asserting that you are convinced the result of
* the computation represented by applying the given function to this PosFiniteFloat's
* value will not produce invalid value.
* Instead of producing such invalid values, this method will throw AssertionError.
*
*
* @param f the Float => Float function to apply to this PosFiniteFloat's
* underlying Float value.
* @return the result of applying this PosFiniteFloat's underlying Float value to
* to the passed function, wrapped in a PosFiniteFloat if it is finite positive (else throws AssertionError).
* @throws AssertionError if the result of applying this PosFiniteFloat's underlying Float value to
* to the passed function is not finite positive.
*/
def ensuringValid(f: Float => Float): PosFiniteFloat = {
val candidateResult: Float = f(value)
if (PosFiniteFloatMacro.isValid(candidateResult)) new PosFiniteFloat(candidateResult)
else throw new AssertionError(s"${candidateResult.toString()}, the result of applying the passed function to ${value.toString()}, was not a valid PosFiniteFloat")
}
/**
* Rounds this `PosFiniteFloat` value to the nearest whole number value that can be expressed as an `PosZInt`, returning the result as a `PosZInt`.
*/
def round: PosZInt = PosZInt.ensuringValid(math.round(value))
/**
* Returns the smallest (closest to 0) `PosFiniteFloat` that is greater than or equal to this `PosFiniteFloat`
* and represents a mathematical integer.
*/
def ceil: PosFiniteFloat = PosFiniteFloat.ensuringValid(math.ceil(value).toFloat)
/**
* Returns the greatest (closest to infinity) `PosZFiniteFloat` that is less than or equal to
* this `PosZFiniteFloat` and represents a mathematical integer.
*/
def floor: PosZFiniteFloat = PosZFiniteFloat.ensuringValid(math.floor(value).toFloat)
}
/**
* The companion object for PosFiniteFloat that offers
* factory methods that produce PosFiniteFloats,
* implicit widening conversions from PosFiniteFloat to
* other numeric types, and maximum and minimum constant values
* for PosFiniteFloat.
*/
object PosFiniteFloat {
/**
* The largest value representable as a finite positive Float,
* which is PosFiniteFloat(3.4028235E38).
*/
final val MaxValue: PosFiniteFloat = PosFiniteFloat.ensuringValid(Float.MaxValue)
/**
* The smallest value representable as a finite positive
* Float, which is PosFiniteFloat(1.4E-45).
*/
final val MinValue: PosFiniteFloat = PosFiniteFloat.ensuringValid(Float.MinPositiveValue) // Can't use the macro here
/**
* A factory method that produces an Option[PosFiniteFloat] given a
* Float value.
*
*
* This method will inspect the passed Float value and if
* it is a finite positive Float, it will return a PosFiniteFloat
* representing that value wrapped in a Some. Otherwise, the passed Float
* value is not finite 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 Float literals at
* compile time, whereas from inspects
* Float values at run time.
*
*
* @param value the Float to inspect, and if finite positive, return
* wrapped in a Some[PosFiniteFloat].
* @return the specified Float value wrapped in a
* Some[PosFiniteFloat], if it is finite positive, else
* None.
*/
def from(value: Float): Option[PosFiniteFloat] =
if (PosFiniteFloatMacro.isValid(value)) Some(new PosFiniteFloat(value)) else None
/**
* A factory/assertion method that produces a PosFiniteFloat given a
* valid Float value, or throws AssertionError,
* if given an invalid Float value.
*
* 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 positive Float, it will return a PosFiniteFloat representing that value.
* Otherwise, the passed Float value is not finite 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 Float literals at
* compile time, whereas from inspects
* Float 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 Float is positive.
*
*
* @param value the Float to inspect, and if finite positive, return
* wrapped in a PosFiniteFloat.
* @return the specified Float value wrapped in a
* PosFiniteFloat, if it is finite positive, else
* throws AssertionError.
* @throws AssertionError if the passed value is not finite positive
*/
def ensuringValid(value: Float): PosFiniteFloat =
if (PosFiniteFloatMacro.isValid(value)) new PosFiniteFloat(value) else {
throw new AssertionError(s"${value.toString()} was not a valid PosFiniteFloat")
}
/**
* A factory/validation method that produces a PosFiniteFloat, wrapped
* in a Success, given a valid Float value, or if the
* given Float is invalid, an AssertionError, wrapped
* in a Failure.
*
*
* This method will inspect the passed Float value and if
* it is a finite positive Float, it will return a PosFiniteFloat
* representing that value, wrapped in a Success.
* Otherwise, the passed Float value is not finite 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.
*
*
* @param value the Float to inspect, and if finite positive, return
* wrapped in a Success(PosFiniteFloat).
* @return the specified Float value wrapped
* in a Success(PosFiniteFloat), if it is finite positive, else a Failure(AssertionError).
*/
def tryingValid(value: Float): Try[PosFiniteFloat] =
if (PosFiniteFloatMacro.isValid(value))
Success(new PosFiniteFloat(value))
else
Failure(new AssertionError(s"${value.toString()} was not a valid PosFiniteFloat"))
/**
* A validation method that produces a Pass
* given a valid Float 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 Float value and if
* it is a finite positive Float, it will return a Pass.
* Otherwise, the passed Float value is finite positive, so this
* method will return a result of type E obtained by passing
* the invalid Float 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
* Float literals at compile time, whereas this method inspects
* Float values at run time.
*
*
* @param value the `Float` to validate that it is finite positive.
* @return a `Pass` if the specified `Float` value is finite positive,
* else a `Fail` containing an error value produced by passing the
* specified `Float` to the given function `f`.
*/
def passOrElse[E](value: Float)(f: Float => E): Validation[E] =
if (PosFiniteFloatMacro.isValid(value)) Pass else Fail(f(value))
/**
* A factory/validation method that produces a PosFiniteFloat, wrapped
* in a Good, given a valid Float value, or if the
* given Float is invalid, an error value of type B
* produced by passing the given invalid Float value
* to the given function f, wrapped in a Bad.
*
*
* This method will inspect the passed Float value and if
* it is a finite positive Float, it will return a PosFiniteFloat
* representing that value, wrapped in a Good.
* Otherwise, the passed Float value is not finite positive, so this
* method will return a result of type B obtained by passing
* the invalid Float 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
* Float literals at compile time, whereas this method inspects
* Float values at run time.
*
*
* @param value the Float to inspect, and if finite positive, return
* wrapped in a Good(PosFiniteFloat).
* @return the specified Float value wrapped
* in a Good(PosFiniteFloat), if it is finite positive, else a Bad(f(value)).
*/
def goodOrElse[B](value: Float)(f: Float => B): PosFiniteFloat Or B =
if (PosFiniteFloatMacro.isValid(value)) Good(PosFiniteFloat.ensuringValid(value)) else Bad(f(value))
/**
* A factory/validation method that produces a PosFiniteFloat, wrapped
* in a Right, given a valid Int value, or if the
* given Int is invalid, an error value of type L
* produced by passing the given invalid Int value
* to the given function f, wrapped in a Left.
*
*
* This method will inspect the passed Int value and if
* it is a finite positive Int, it will return a PosFiniteFloat
* representing that value, wrapped in a Right.
* Otherwise, the passed Int value is not finite positive, so this
* method will return a result of type L obtained by passing
* the invalid Int 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
* Int literals at compile time, whereas this method inspects
* Int values at run time.
*
*
* @param value the Int to inspect, and if finite positive, return
* wrapped in a Right(PosFiniteFloat).
* @return the specified Int value wrapped
* in a Right(PosFiniteFloat), if it is finite positive, else a Left(f(value)).
*/
def rightOrElse[L](value: Float)(f: Float => L): Either[L, PosFiniteFloat] =
if (PosFiniteFloatMacro.isValid(value)) Right(PosFiniteFloat.ensuringValid(value)) else Left(f(value))
/**
* A predicate method that returns true if a given
* Float value is finite positive.
*
* @param value the Float to inspect, and if finite positive, return true.
* @return true if the specified Float is finite positive, else false.
*/
def isValid(value: Float): Boolean = PosFiniteFloatMacro.isValid(value)
/**
* A factory method that produces a PosFiniteFloat given a
* Float value and a default PosFiniteFloat.
*
*
* This method will inspect the passed Float value and if
* it is a finite positive Float, it will return a PosFiniteFloat representing that value.
* Otherwise, the passed Float value is not finite 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 Float literals at
* compile time, whereas from inspects
* Float values at run time.
*
*
* @param value the Float to inspect, and if finite positive, return.
* @param default the PosFiniteFloat to return if the passed
* Float value is not finite positive.
* @return the specified Float value wrapped in a
* PosFiniteFloat, if it is finite positive, else the
* default PosFiniteFloat value.
*/
def fromOrElse(value: Float, default: => PosFiniteFloat): PosFiniteFloat =
if (PosFiniteFloatMacro.isValid(value)) new PosFiniteFloat(value) else default
import language.experimental.macros
import scala.language.implicitConversions
/**
* A factory method, implemented via a macro, that produces a
* PosFiniteFloat if passed a valid Float
* literal, otherwise a compile time error.
*
*
* The macro that implements this method will inspect the
* specified Float expression at compile time. If
* the expression is a finite positive Float literal,
* it will return a PosFiniteFloat representing that value.
* Otherwise, the passed Float expression is either a literal
* that is not finite 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 Float literals at compile
* time, whereas from inspects Float
* values at run time.
*
*
* @param value the Float literal expression to
* inspect at compile time, and if finite positive, to return
* wrapped in a PosFiniteFloat at run time.
* @return the specified, valid Float literal
* value wrapped in a PosFiniteFloat. (If the
* specified expression is not a valid Float
* literal, the invocation of this method will not
* compile.)
*/
inline implicit def apply(value: => Float): PosFiniteFloat = ${ PosFiniteFloatMacro('{value}) }
/**
* Implicit widening conversion from PosFiniteFloat to
* Float.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the
* specified PosFiniteFloat
*/
implicit def widenToFloat(pos: PosFiniteFloat): Float = pos.value
/**
* Implicit widening conversion from PosFiniteFloat to
* Double.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the
* specified PosFiniteFloat, widened to
* Double.
*/
implicit def widenToDouble(pos: PosFiniteFloat): Double = pos.value
/**
* Implicit widening conversion from PosFiniteFloat to PosFloat.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Float and wrapped in a PosFloat.
*/
implicit def widenToPosFloat(pos: PosFiniteFloat): PosFloat = PosFloat.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a PosDouble.
*/
implicit def widenToPosDouble(pos: PosFiniteFloat): PosDouble = PosDouble.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosZFloat.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Float and wrapped in a PosZFloat.
*/
implicit def widenToPosZFloat(pos: PosFiniteFloat): PosZFloat = PosZFloat.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosZDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a PosZDouble.
*/
implicit def widenToPosZDouble(pos: PosFiniteFloat): PosZDouble = PosZDouble.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to NonZeroFloat.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Float and wrapped in a NonZeroFloat.
*/
implicit def widenToNonZeroFloat(pos: PosFiniteFloat): NonZeroFloat = NonZeroFloat.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to NonZeroDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a NonZeroDouble.
*/
implicit def widenToNonZeroDouble(pos: PosFiniteFloat): NonZeroDouble = NonZeroDouble.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosFiniteDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a PosFiniteDouble.
*/
implicit def widenToPosFiniteDouble(pos: PosFiniteFloat): PosFiniteDouble = PosFiniteDouble.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosZFiniteFloat.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Float and wrapped in a PosZFiniteFloat.
*/
implicit def widenToPosZFiniteFloat(pos: PosFiniteFloat): PosZFiniteFloat = PosZFiniteFloat.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to PosZFiniteDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a PosZFiniteDouble.
*/
implicit def widenToPosZFiniteDouble(pos: PosFiniteFloat): PosZFiniteDouble = PosZFiniteDouble.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to FiniteFloat.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Float and wrapped in a FiniteFloat.
*/
implicit def widenToFiniteFloat(pos: PosFiniteFloat): FiniteFloat = FiniteFloat.ensuringValid(pos.value)
/**
* Implicit widening conversion from PosFiniteFloat to FiniteDouble.
*
* @param pos the PosFiniteFloat to widen
* @return the Float value underlying the specified PosFiniteFloat,
* widened to Double and wrapped in a FiniteDouble.
*/
implicit def widenToFiniteDouble(pos: PosFiniteFloat): FiniteDouble = FiniteDouble.ensuringValid(pos.value)
/**
* Implicit Ordering instance.
*/
implicit val ordering: Ordering[PosFiniteFloat] =
new Ordering[PosFiniteFloat] {
def compare(x: PosFiniteFloat, y: PosFiniteFloat): Int = x.toFloat.compare(y)
}
/**
* The smallest positive value greater than 0.0d representable as a PosFloat, which is PosFloat(1.4E-45).
*/
final val MinPositiveValue: PosFloat = PosFloat.ensuringValid(Float.MinPositiveValue)
}