All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.scalactic.anyvals.NegFiniteFloat.scala Maven / Gradle / Ivy

The newest version!
/*
 * 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 negative Floats.
 *
 * 

* Note: a NegFiniteFloat may not equal 0.0. If you want negative number or 0, use [[NegZFiniteFloat]]. *

* *

* Because NegFiniteFloat is an AnyVal it * will usually be as efficient as an Float, being * boxed only when an Float would have been boxed. *

* *

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

* *
 * scala> import anyvals._
 * import anyvals._
 *
 * scala> NegFiniteFloat(-42.1fF)
 * res0: org.scalactic.anyvals.NegFiniteFloat = NegFiniteFloat(-42.1f)
 *
 * scala> NegFiniteFloat(0.0fF)
 * <console>:14: error: NegFiniteFloat.apply can only be invoked on a finite negative (i < 0.0f && i != Float.NegativeInfinity) floating point literal, like NegFiniteFloat(-42.1fF).
 *               NegFiniteFloat(-42.1fF)
 *                       ^
 * 
* *

* NegFiniteFloat.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 NegFiniteFloat.apply, you'll get a compiler error * that suggests you use a different factor method, * NegFiniteFloat.from, instead: *

* *
 * scala> val x = -42.1fF
 * x: Float = -42.1f
 *
 * scala> NegFiniteFloat(x)
 * <console>:15: error: NegFiniteFloat.apply can only be invoked on a floating point literal, like NegFiniteFloat(-42.1fF). Please use NegFiniteFloat.from instead.
 *               NegFiniteFloat(x)
 *                       ^
 * 
* *

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

* *
 * scala> NegFiniteFloat.from(x)
 * res3: Option[org.scalactic.anyvals.NegFiniteFloat] = Some(NegFiniteFloat(-42.1f))
 *
 * scala> val y = 0.0fF
 * y: Float = 0.0f
 *
 * scala> NegFiniteFloat.from(y)
 * res4: Option[org.scalactic.anyvals.NegFiniteFloat] = None
 * 
* *

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

* *
 * scala> def invert(pos: NegFiniteFloat): Float = Float.MaxValue - pos
 * invert: (pos: org.scalactic.anyvals.NegFiniteFloat)Float
 *
 * scala> invert(-42.1fF)
 * res5: Float = 3.4028235E38
 *
 * scala> invert(Float.MaxValue)
 * res6: Float = 0.0
 *
 * scala> invert(0.0fF)
 * <console>:15: error: NegFiniteFloat.apply can only be invoked on a finite negative (i < 0.0f && i != Float.NegativeInfinity) floating point literal, like NegFiniteFloat(-42.1fF).
 *               invert(0.0F)
 *                      ^
 *
 * scala> invert(0.0fF)
 * <console>:15: error: NegFiniteFloat.apply can only be invoked on a finite negative (i < 0.0f && i != Float.NegativeInfinity) floating point literal, like NegFiniteFloat(-42.1fF).
 *               invert(0.0fF)
 *                       ^
 *
 * 
* *

* This example also demonstrates that the NegFiniteFloat * companion object also defines implicit widening conversions * when no loss of precision will occur. This makes it convenient to use a * NegFiniteFloat 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 * NegFiniteFloat (the type of pos), you can * still subtract pos, because the * NegFiniteFloat will be implicitly widened to * Float. *

* * @param value The Float value underlying this NegFiniteFloat. */ final class NegFiniteFloat private (val value: Float) extends AnyVal { /** * A string representation of this NegFiniteFloat. */ override def toString: String = s"NegFiniteFloat(${value.toString()}f)" /** * Converts this NegFiniteFloat to a Byte. */ def toByte: Byte = value.toByte /** * Converts this NegFiniteFloat to a Short. */ def toShort: Short = value.toShort /** * Converts this NegFiniteFloat to a Char. */ def toChar: Char = value.toChar /** * Converts this NegFiniteFloat to an Int. */ def toInt: Int = value.toInt /** * Converts this NegFiniteFloat to a Long. */ def toLong: Long = value.toLong /** * Converts this NegFiniteFloat to a Float. */ def toFloat: Float = value.toFloat /** * Converts this NegFiniteFloat to a Double. */ def toDouble: Double = value.toDouble /** Returns this value, unmodified. */ def unary_+ : NegFiniteFloat = this /** Returns the negation of this value. */ def unary_- : PosFiniteFloat = PosFiniteFloat.ensuringValid(-value) /** * Converts this NegFiniteFloat'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: NegFiniteFloat): NegFiniteFloat = if (math.max(value, that.value) == value) this else that /** * Returns this if this < that or that otherwise. */ def min(that: NegFiniteFloat): NegFiniteFloat = if (math.min(value, that.value) == value) this else that /** * Indicates whether this `NegFiniteFloat` 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 NegFiniteFloat, * else throws AssertionError. * *

* This method will inspect the result of applying the given function to this * NegFiniteFloat's underlying Float value and if the result * is finite negative, it will return a NegFiniteFloat representing that value. * Otherwise, the Float value returned by the given function is * not finite negative, 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 negative. * With this method, you are asserting that you are convinced the result of * the computation represented by applying the given function to this NegFiniteFloat'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 NegFiniteFloat's * underlying Float value. * @return the result of applying this NegFiniteFloat's underlying Float value to * to the passed function, wrapped in a NegFiniteFloat if it is finite negative (else throws AssertionError). * @throws AssertionError if the result of applying this NegFiniteFloat's underlying Float value to * to the passed function is not finite negative. */ def ensuringValid(f: Float => Float): NegFiniteFloat = { val candidateResult: Float = f(value) if (NegFiniteFloatMacro.isValid(candidateResult)) new NegFiniteFloat(candidateResult) else throw new AssertionError(s"${candidateResult.toString()}, the result of applying the passed function to ${value.toString()}, was not a valid NegFiniteFloat") } /** * Rounds this `NegFiniteFloat` value to the nearest whole number value that can be expressed as an `NegZInt`, returning the result as a `NegZInt`. */ def round: NegZInt = NegZInt.ensuringValid(math.round(value)) /** * Returns the smallest (closest to 0) `NegZFiniteFloat` that is greater than or equal to this `NegZFiniteFloat` * and represents a mathematical integer. */ def ceil: NegZFiniteFloat = NegZFiniteFloat.ensuringValid(math.ceil(value).toFloat) /** * Returns the greatest (closest to infinity) `NegFiniteFloat` that is less than or equal to * this `NegFiniteFloat` and represents a mathematical integer. */ def floor: NegFiniteFloat = NegFiniteFloat.ensuringValid(math.floor(value).toFloat) } /** * The companion object for NegFiniteFloat that offers * factory methods that produce NegFiniteFloats, * implicit widening conversions from NegFiniteFloat to * other numeric types, and maximum and minimum constant values * for NegFiniteFloat. */ object NegFiniteFloat { /** * The largest value representable as a finite negative Float, * which is NegFiniteFloat(-1.4E-45). */ final val MaxValue: NegFiniteFloat = NegFiniteFloat.ensuringValid(-Float.MinPositiveValue) /** * The smallest value representable as a finite negative * Float, which is NegFiniteFloat(-3.4028235E38). */ final val MinValue: NegFiniteFloat = NegFiniteFloat.ensuringValid(Float.MinValue) // Can't use the macro here /** * A factory method that produces an Option[NegFiniteFloat] given a * Float value. * *

* This method will inspect the passed Float value and if * it is a finite negative Float, it will return a NegFiniteFloat * representing that value wrapped in a Some. Otherwise, the passed Float * value is not finite negative, 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 negative, return * wrapped in a Some[NegFiniteFloat]. * @return the specified Float value wrapped in a * Some[NegFiniteFloat], if it is finite negative, else * None. */ def from(value: Float): Option[NegFiniteFloat] = if (NegFiniteFloatMacro.isValid(value)) Some(new NegFiniteFloat(value)) else None /** * A factory/assertion method that produces a NegFiniteFloat 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 negative Float, it will return a NegFiniteFloat representing that value. * Otherwise, the passed Float value is not finite negative, 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 negative, return * wrapped in a NegFiniteFloat. * @return the specified Float value wrapped in a * NegFiniteFloat, if it is finite negative, else * throws AssertionError. * @throws AssertionError if the passed value is not finite negative */ def ensuringValid(value: Float): NegFiniteFloat = if (NegFiniteFloatMacro.isValid(value)) new NegFiniteFloat(value) else { throw new AssertionError(s"${value.toString()} was not a valid NegFiniteFloat") } /** * A factory/validation method that produces a NegFiniteFloat, 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 negative Float, it will return a NegFiniteFloat * representing that value, wrapped in a Success. * Otherwise, the passed Float value is not finite negative, 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 negative, return * wrapped in a Success(NegFiniteFloat). * @return the specified Float value wrapped * in a Success(NegFiniteFloat), if it is finite negative, else a Failure(AssertionError). */ def tryingValid(value: Float): Try[NegFiniteFloat] = if (NegFiniteFloatMacro.isValid(value)) Success(new NegFiniteFloat(value)) else Failure(new AssertionError(s"${value.toString()} was not a valid NegFiniteFloat")) /** * 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 negative Float, it will return a Pass. * Otherwise, the passed Float value is finite negative, 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 negative. * @return a `Pass` if the specified `Float` value is finite negative, * 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 (NegFiniteFloatMacro.isValid(value)) Pass else Fail(f(value)) /** * A factory/validation method that produces a NegFiniteFloat, 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 negative Float, it will return a NegFiniteFloat * representing that value, wrapped in a Good. * Otherwise, the passed Float value is not finite negative, 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 negative, return * wrapped in a Good(NegFiniteFloat). * @return the specified Float value wrapped * in a Good(NegFiniteFloat), if it is finite negative, else a Bad(f(value)). */ def goodOrElse[B](value: Float)(f: Float => B): NegFiniteFloat Or B = if (NegFiniteFloatMacro.isValid(value)) Good(NegFiniteFloat.ensuringValid(value)) else Bad(f(value)) /** * A factory/validation method that produces a NegFiniteFloat, 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 negative Int, it will return a NegFiniteFloat * representing that value, wrapped in a Right. * Otherwise, the passed Int value is not finite negative, 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 negative, return * wrapped in a Right(NegFiniteFloat). * @return the specified Int value wrapped * in a Right(NegFiniteFloat), if it is finite negative, else a Left(f(value)). */ def rightOrElse[L](value: Float)(f: Float => L): Either[L, NegFiniteFloat] = if (NegFiniteFloatMacro.isValid(value)) Right(NegFiniteFloat.ensuringValid(value)) else Left(f(value)) /** * A predicate method that returns true if a given * Float value is finite negative. * * @param value the Float to inspect, and if finite negative, return true. * @return true if the specified Float is finite negative, else false. */ def isValid(value: Float): Boolean = NegFiniteFloatMacro.isValid(value) /** * A factory method that produces a NegFiniteFloat given a * Float value and a default NegFiniteFloat. * *

* This method will inspect the passed Float value and if * it is a finite negative Float, it will return a NegFiniteFloat representing that value. * Otherwise, the passed Float value is not finite negative, 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 negative, return. * @param default the NegFiniteFloat to return if the passed * Float value is not finite negative. * @return the specified Float value wrapped in a * NegFiniteFloat, if it is finite negative, else the * default NegFiniteFloat value. */ def fromOrElse(value: Float, default: => NegFiniteFloat): NegFiniteFloat = if (NegFiniteFloatMacro.isValid(value)) new NegFiniteFloat(value) else default import language.experimental.macros import scala.language.implicitConversions /** * A factory method, implemented via a macro, that produces a * NegFiniteFloat 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 negative Float literal, * it will return a NegFiniteFloat representing that value. * Otherwise, the passed Float expression is either a literal * that is not finite negative, 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 negative, to return * wrapped in a NegFiniteFloat at run time. * @return the specified, valid Float literal * value wrapped in a NegFiniteFloat. (If the * specified expression is not a valid Float * literal, the invocation of this method will not * compile.) */ inline implicit def apply(value: => Float): NegFiniteFloat = ${ NegFiniteFloatMacro('{value}) } /** * Implicit widening conversion from NegFiniteFloat to * Float. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the * specified NegFiniteFloat */ implicit def widenToFloat(pos: NegFiniteFloat): Float = pos.value /** * Implicit widening conversion from NegFiniteFloat to * Double. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the * specified NegFiniteFloat, widened to * Double. */ implicit def widenToDouble(pos: NegFiniteFloat): Double = pos.value /** * Implicit widening conversion from NegFiniteFloat to NegFloat. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Float and wrapped in a NegFloat. */ implicit def widenToNegFloat(pos: NegFiniteFloat): NegFloat = NegFloat.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a NegDouble. */ implicit def widenToNegDouble(pos: NegFiniteFloat): NegDouble = NegDouble.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegZFloat. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Float and wrapped in a NegZFloat. */ implicit def widenToNegZFloat(pos: NegFiniteFloat): NegZFloat = NegZFloat.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegZDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a NegZDouble. */ implicit def widenToNegZDouble(pos: NegFiniteFloat): NegZDouble = NegZDouble.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NonZeroFloat. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Float and wrapped in a NonZeroFloat. */ implicit def widenToNonZeroFloat(pos: NegFiniteFloat): NonZeroFloat = NonZeroFloat.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NonZeroDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a NonZeroDouble. */ implicit def widenToNonZeroDouble(pos: NegFiniteFloat): NonZeroDouble = NonZeroDouble.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegFiniteDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a NegFiniteDouble. */ implicit def widenToNegFiniteDouble(pos: NegFiniteFloat): NegFiniteDouble = NegFiniteDouble.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegZFiniteFloat. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Float and wrapped in a NegZFiniteFloat. */ implicit def widenToNegZFiniteFloat(pos: NegFiniteFloat): NegZFiniteFloat = NegZFiniteFloat.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to NegZFiniteDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a NegZFiniteDouble. */ implicit def widenToNegZFiniteDouble(pos: NegFiniteFloat): NegZFiniteDouble = NegZFiniteDouble.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to FiniteFloat. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Float and wrapped in a FiniteFloat. */ implicit def widenToFiniteFloat(pos: NegFiniteFloat): FiniteFloat = FiniteFloat.ensuringValid(pos.value) /** * Implicit widening conversion from NegFiniteFloat to FiniteDouble. * * @param pos the NegFiniteFloat to widen * @return the Float value underlying the specified NegFiniteFloat, * widened to Double and wrapped in a FiniteDouble. */ implicit def widenToFiniteDouble(pos: NegFiniteFloat): FiniteDouble = FiniteDouble.ensuringValid(pos.value) /** * Implicit Ordering instance. */ implicit val ordering: Ordering[NegFiniteFloat] = new Ordering[NegFiniteFloat] { def compare(x: NegFiniteFloat, y: NegFiniteFloat): Int = x.toFloat.compare(y) } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy