org.scalactic.anyvals.PosFloat.scala Maven / Gradle / Ivy
/*
* Copyright 2001-2014 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.language.implicitConversions
import scala.collection.immutable.NumericRange
/**
* An AnyVal for positive Floats.
*
* Note: a PosFloat may not equal 0. If you want positive
* number or 0, use [[PosZFloat]].
*
*
* Because PosFloat is an AnyVal it
* will usually be as efficient as an Float, being
* boxed only when an Float would have been boxed.
*
*
*
* The PosFloat.apply factory method is implemented
* in terms of a macro that checks literals for validity at
* compile time. Calling PosFloat.apply with a
* literal Float value will either produce a valid
* PosFloat instance at run time or an error at
* compile time. Here's an example:
*
*
*
* scala> import anyvals._
* import anyvals._
*
* scala> PosFloat(1.0F)
* res0: org.scalactic.anyvals.PosFloat = PosFloat(1.0)
*
* scala> PosFloat(0.0F)
* <console>:14: error: PosFloat.apply can only be invoked on a positive (i > 0.0F) floating point literal, like PosFloat(42.0F).
* PosFloat(0.0F)
* ^
*
*
*
* PosFloat.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 PosFloat.apply, you'll get a compiler error
* that suggests you use a different factor method,
* PosFloat.from, instead:
*
*
*
* scala> val x = 1.0F
* x: Float = 1.0
*
* scala> PosFloat(x)
* <console>:15: error: PosFloat.apply can only be invoked on a floating point literal, like PosFloat(42.0F). Please use PosFloat.from instead.
* PosFloat(x)
* ^
*
*
*
* The PosFloat.from factory method will inspect
* the value at runtime and return an
* Option[PosFloat]. If the value is valid,
* PosFloat.from will return a
* Some[PosFloat], else it will return a
* None. Here's an example:
*
*
*
* scala> PosFloat.from(x)
* res3: Option[org.scalactic.anyvals.PosFloat] = Some(PosFloat(1.0))
*
* scala> val y = 0.0F
* y: Float = 0.0
*
* scala> PosFloat.from(y)
* res4: Option[org.scalactic.anyvals.PosFloat] = None
*
*
*
* The PosFloat.apply factory method is marked
* implicit, so that you can pass literal Floats
* into methods that require PosFloat, and get the
* same compile-time checking you get when calling
* PosFloat.apply explicitly. Here's an example:
*
*
*
* scala> def invert(pos: PosFloat): Float = Float.MaxValue - pos
* invert: (pos: org.scalactic.anyvals.PosFloat)Float
*
* scala> invert(1.1F)
* res5: Float = 3.4028235E38
*
* scala> invert(Float.MaxValue)
* res6: Float = 0.0
*
* scala> invert(0.0F)
* <console>:15: error: PosFloat.apply can only be invoked on a positive (i > 0.0F) floating point literal, like PosFloat(42.0F).
* invert(0.0F)
* ^
*
* scala> invert(-1.1F)
* <console>:15: error: PosFloat.apply can only be invoked on a positive (i > 0.0F) floating point literal, like PosFloat(42.0F).
* invert(-1.1F)
* ^
*
*
*
*
* This example also demonstrates that the PosFloat
* companion object also defines implicit widening conversions
* when no loss of precision will occur. This makes it convenient to use a
* PosFloat 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
* PosFloat (the type of pos), you can
* still subtract pos, because the
* PosFloat will be implicitly widened to
* Float.
*
*
* @param value The Float value underlying this PosFloat.
*/
final class PosFloat private (val value: Float) extends AnyVal {
/**
* A string representation of this PosFloat.
*/
override def toString: String = s"PosFloat($value)"
/**
* Converts this PosFloat to a Byte.
*/
def toByte: Byte = value.toByte
/**
* Converts this PosFloat to a Short.
*/
def toShort: Short = value.toShort
/**
* Converts this PosFloat to a Char.
*/
def toChar: Char = value.toChar
/**
* Converts this PosFloat to an Int.
*/
def toInt: Int = value.toInt
/**
* Converts this PosFloat to a Long.
*/
def toLong: Long = value.toLong
/**
* Converts this PosFloat to a Float.
*/
def toFloat: Float = value.toFloat
/**
* Converts this PosFloat to a Double.
*/
def toDouble: Double = value.toDouble
/** Returns this value, unmodified. */
def unary_+ : PosFloat = this
/** Returns the negation of this value. */
def unary_- : Float = -value
/**
* Converts this PosFloat's value to a string then concatenates the given string.
*/
def +(x: String): String = value + x
/** 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
def isPosInfinity: Boolean = Float.PositiveInfinity == value
/**
* Returns this if this > that or that otherwise.
*/
def max(that: PosFloat): PosFloat = if (math.max(value, that.value) == value) this else that
/**
* Returns this if this < that or that otherwise.
*/
def min(that: PosFloat): PosFloat = if (math.min(value, that.value) == value) this else that
def isWhole = {
val longValue = value.toLong
longValue.toFloat == value || longValue == Long.MaxValue && value < Float.PositiveInfinity || longValue == Long.MinValue && value > Float.NegativeInfinity
}
def round: PosZInt = {
import scala.util.Try
import scala.util.Success
import scala.util.Failure
val roundedInt: Int = math.round(value)
val result = Try(PosZInt.from(math.round(value)).get)
result match {
case Failure(ex) => println("PosZInt round failed")
println(s"value was $value")
println(s"result was $result")
throw ex
case Success(v) => v
}
// PosZInt.from(math.round(value)).get // Also could be zero.
}
def ceil: PosFloat = PosFloat.from(math.ceil(value.toDouble).toFloat).get // I think this one is safe, but try NaN
def floor: PosZFloat = PosZFloat.from(math.floor(value.toDouble).toFloat).get // Could be zero.
/** 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
// adapted from RichInt:
/**
* Create a Range from this PosFloat value
* until the specified end (exclusive) with step value 1.
*
* @param end The final bound of the range to make.
* @return A [[scala.collection.immutable.Range.Partial[Float, NumericRange[Float]]]] from `this` up to but
* not including `end`.
*/
def until(end: Float): Range.Partial[Float, NumericRange[Float]] =
value.until(end)
/**
* Create a Range (exclusive) from this PosFloat value
* until the specified end (exclusive) with the specified step value.
*
* @param end The final bound of the range to make.
* @param end The final bound of the range to make.
* @param step The number to increase by for each step of the range.
* @return A [[scala.collection.immutable.NumericRange.Exclusive[Float]]] from `this` up to but
* not including `end`.
*/
def until(end: Float, step: Float): NumericRange.Exclusive[Float] =
value.until(end, step)
/**
* Create an inclusive Range from this PosFloat value
* to the specified end with step value 1.
*
* @param end The final bound of the range to make.
* @return A [[scala.collection.immutable.Range.Partial[Float], NumericRange[Float]]] from `'''this'''` up to
* and including `end`.
*/
def to(end: Float): Range.Partial[Float, NumericRange[Float]] =
value.to(end)
/**
* Create an inclusive Range from this PosFloat value
* to the specified end with the specified step value.
*
* @param end The final bound of the range to make.
* @param step The number to increase by for each step of the range.
* @return A [[scala.collection.immutable.NumericRange.Inclusive[Float]]] from `'''this'''` up to
* and including `end`.
*/
def to(end: Float, step: Float): NumericRange.Inclusive[Float] =
value.to(end, step)
}
/**
* The companion object for PosFloat that offers
* factory methods that produce PosFloats,
* implicit widening conversions from PosFloat to
* other numeric types, and maximum and minimum constant values
* for PosFloat.
*/
object PosFloat {
/**
* The largest value representable as a positive Float,
* which is PosFloat(3.4028235E38).
*/
final val MaxValue: PosFloat = PosFloat.from(Float.MaxValue).get
/**
* The smallest value representable as a positive
* Float, which is PosFloat(1.4E-45).
*/
final val MinValue: PosFloat = PosFloat.from(Float.MinPositiveValue).get // Can't use the macro here
/**
* A factory method that produces an Option[PosFloat] given a
* Float value.
*
*
* This method will inspect the passed Float value and if
* it is a positive Float, i.e., a value greater
* than 0.0, it will return a PosFloat representing that value,
* wrapped in a Some. Otherwise, the passed Float
* value is 0.0 or 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 positive, return
* wrapped in a Some[PosFloat].
* @return the specified Float value wrapped in a
* Some[PosFloat], if it is positive, else
* None.
*/
def from(value: Float): Option[PosFloat] =
if (value > 0.0F) Some(new PosFloat(value)) else None
import language.experimental.macros
import scala.language.implicitConversions
/**
* A factory method, implemented via a macro, that produces a
* PosFloat 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 positive Float literal,
* i.e., with a value greater than 0.0, it will return
* a PosFloat representing that value. Otherwise,
* the passed Float expression is either a literal
* that is 0.0 or 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 positive, to return
* wrapped in a PosFloat at run time.
* @return the specified, valid Float literal
* value wrapped in a PosFloat. (If the
* specified expression is not a valid Float
* literal, the invocation of this method will not
* compile.)
*/
implicit def apply(value: Float): PosFloat = macro PosFloatMacro.apply
/**
* Implicit widening conversion from PosFloat to
* Float.
*
* @param pos the PosFloat to widen
* @return the Float value underlying the
* specified PosFloat
*/
implicit def widenToFloat(pos: PosFloat): Float = pos.value
/**
* Implicit widening conversion from PosFloat to
* Double.
*
* @param pos the PosFloat to widen
* @return the Float value underlying the
* specified PosFloat, widened to
* Double.
*/
implicit def widenToDouble(pos: PosFloat): Double = pos.value
/**
* Implicit widening conversion from PosFloat to
* PosDouble.
*
* @param pos the PosFloat to widen
* @return the Float value underlying the
* specified PosFloat, widened to
* Double and wrapped in a
* PosDouble.
*/
implicit def widenToPosDouble(pos: PosFloat): PosDouble = PosDouble.from(pos.value).get
/**
* Implicit widening conversion from PosFloat to
* PosZFloat.
*
* @param pos the PosFloat to widen
* @return the Float value underlying the
* specified PosFloat wrapped in a
* PosZFloat.
*/
implicit def widenToPosZFloat(pos: PosFloat): PosZFloat = PosZFloat.from(pos.value).get
/**
* Implicit widening conversion from PosFloat to
* PosZDouble.
*
* @param pos the PosFloat to widen
* @return the Float value underlying the
* specified PosFloat, widened to
* Double and wrapped in a
* PosZDouble.
*/
implicit def widenToPosZDouble(pos: PosFloat): PosZDouble = PosZDouble.from(pos.value).get
/**
* Implicit Ordering instance.
*/
implicit val posFloatOrd: Ordering[PosFloat] =
new Ordering[PosFloat] {
def compare(x: PosFloat, y: PosFloat): Int = x.toFloat.compare(y)
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy