case class QuantityRange[A <: Quantity[A]](lower: A, upper: A) extends Product with Serializable
Represents a Range starting at one Quantity value and going up to another
 A
the Quantity Type
 lower
Quantity representing the lower bound of the range
 upper
Quantity representing the upper bound of the range
 Source
 QuantityRange.scala
 Since
0.1
 Alphabetic
 By Inheritance
 QuantityRange
 Serializable
 Serializable
 Product
 Equals
 AnyRef
 Any
 Hide All
 Show All
 Public
 All
Instance Constructors

new
QuantityRange(lower: A, upper: A)
 lower
Quantity representing the lower bound of the range
 upper
Quantity representing the upper bound of the range
Value Members

final
def
!=(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
##(): Int
 Definition Classes
 AnyRef → Any

def
*(multiple: Double): QuantitySeries[A]
times

def
++(that: A): QuantityRange[A]
int

def
++(): QuantityRange[A]
inc

def
+(that: A): QuantityRange[A]
incFromDecTo

def
+=(that: A): QuantityRange[A]
incFrom

def
+(that: A): QuantityRange[A]
decFromIncTo

def
(that: A): QuantityRange[A]
dec

def
(): QuantityRange[A]
dec

def
=(that: A): QuantityRange[A]
decFrom

def
/(divisor: Double): QuantitySeries[A]
divide

def
/(that: A): QuantitySeries[A]
divide

def
/:[B](divisor: Double, z: B)(op: (B, QuantityRange[A]) ⇒ B): B
foldLeft

def
/:[B](size: A, z: B)(op: (B, QuantityRange[A]) ⇒ B): B
foldLeft

def
:\[B](divisor: Double, z: B)(op: (QuantityRange[A], B) ⇒ B): B
foldRight

def
:\[B](size: A, z: B)(op: (QuantityRange[A], B) ⇒ B): B
foldRight

def
=+(that: A): QuantityRange[A]
incTo

def
=(that: A): QuantityRange[A]
decTo

final
def
==(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
asInstanceOf[T0]: T0
 Definition Classes
 Any

def
clone(): AnyRef
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

def
contains(that: QuantityRange[A]): Boolean
Return true if
that
range is completely contained withthis
range, otherwise falseReturn true if
that
range is completely contained withthis
range, otherwise false that
Quantity

def
contains(q: A): Boolean
Returns true if the quantity is contained within this range, otherwise false
Returns true if the quantity is contained within this range, otherwise false
 q
Quantity

def
dec(that: A): QuantityRange[A]
Decrements the range's from and to values by an amount equal to the value of
that
Decrements the range's from and to values by an amount equal to the value of
that
 that
Quantity

lazy val
dec: QuantityRange[A]
Decrements the range's from and to value by an amount equal to the Quantity value of the range

def
decFrom(that: A): QuantityRange[A]
Decrements the
from
value by an amount equal to the value ofthat
Decrements the
from
value by an amount equal to the value ofthat
 that
Quantity

def
decFromIncTo(that: A): QuantityRange[A]
Decrements the
from
value and increments theto
by an amount equal to the value ofthat
Decrements the
from
value and increments theto
by an amount equal to the value ofthat
 that
Quantity
 def decTo(that: A): QuantityRange[A]

def
divide(that: Double): QuantitySeries[A]
Divides the range into a Seq of
divisor
ranges The Seq will begin atfrom
and go tillto
.Divides the range into a Seq of
divisor
ranges The Seq will begin atfrom
and go tillto
. Ifthat
is an integer value, the range will evenly divided at all points. Ifthat
has a fractional component, the first n1 ranges will be evenly divided by thethat
and the last range in the list will contain the remainder.QuantityRange(Each(1), Each(4)) / 3 => Vector(QuantityRange(1.0 ea,2.0 ea), QuantityRange(2.0 ea,3.0 ea), QuantityRange(3.0 ea,4.0 ea))
 that
Double

def
divide(that: A): QuantitySeries[A]
Divides the range into a Series of ranges each with a range of size
that
The Seq will begin atfrom
and go tillto
.Divides the range into a Series of ranges each with a range of size
that
The Seq will begin atfrom
and go tillto
. If the range is not evenly divisible bythat
, the last item in the list will contain the remainderQuantityRange(Each(1), Each(4)) / Each(1) => Vector(QuantityRange(1.0 ea,2.0 ea), QuantityRange(2.0 ea,3.0 ea), QuantityRange(3.0 ea,4.0 ea))
 that
Quantity

final
def
eq(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
finalize(): Unit
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( classOf[java.lang.Throwable] )

def
foldLeft[B](divisor: Double, z: B)(op: (B, QuantityRange[A]) ⇒ B): B
Divides the range into a Seq of ranges of
size
each and applies a foldLeft operationDivides the range into a Seq of ranges of
size
each and applies a foldLeft operation B
the result type of the binary operator
 divisor
The number of ranges to split the range into
 z
the start value
 op
the binary operator

def
foldLeft[B](size: A, z: B)(op: (B, QuantityRange[A]) ⇒ B): B
Divides the range into a Seq of ranges of
size
each and applies a foldLeft operationDivides the range into a Seq of ranges of
size
each and applies a foldLeft operation B
the result type of the binary operator
 size
Quantity representing the size for each QuantityRange in the Seq
 z
the start value
 op
the binary operator

def
foldRight[B](divisor: Double, z: B)(op: (QuantityRange[A], B) ⇒ B): B
Divides the range into a Seq of ranges of
size
each and applies a foldRight operationDivides the range into a Seq of ranges of
size
each and applies a foldRight operation B
the result type of the binary operator
 divisor
The number of ranges to split the range into
 z
the start value
 op
the binary operator

def
foldRight[B](size: A, z: B)(op: (QuantityRange[A], B) ⇒ B): B
Divides the range into a Seq of ranges of
size
each and applies a foldRight operationDivides the range into a Seq of ranges of
size
each and applies a foldRight operation B
the result type of the binary operator
 size
Quantity representing the size for each QuantityRange in the Seq
 z
the start value
 op
the binary operator

def
foreach[U](divisor: Double)(op: (QuantityRange[A]) ⇒ U): Unit
Divides the range into a Seq of
divisor
ranges and applies a f to each elementDivides the range into a Seq of
divisor
ranges and applies a f to each element divisor
Quantity representing the size for each QuantityRange in the Seq
 op
the side affecting operation

def
foreach[U](size: A)(op: (QuantityRange[A]) ⇒ U): Unit
Divides the range into a Seq of ranges of
size
each and applies a f to each elementDivides the range into a Seq of ranges of
size
each and applies a f to each element size
Quantity representing the size for each QuantityRange in the Seq
 op
the side affecting operation

final
def
getClass(): Class[_]
 Definition Classes
 AnyRef → Any

def
inc(that: A): QuantityRange[A]
Increments the range's from and to values by an amount equal to the value of
that
Increments the range's from and to values by an amount equal to the value of
that
 that
Quantity

lazy val
inc: QuantityRange[A]
Increments the range's from and to values by an amount equal to the Quantity value of the range

def
incFrom(that: A): QuantityRange[A]
Increments the
from
value by an amount equal to the value ofthat
Increments the
from
value by an amount equal to the value ofthat
 that
Quantity

def
incFromDecTo(that: A): QuantityRange[A]
Increments the
from
value and decrements theto
by an amount equal to the value ofthat
Increments the
from
value and decrements theto
by an amount equal to the value ofthat
 that
Quantity

def
incTo(that: A): QuantityRange[A]
Increments the
to
value by an amount equal to the value ofthat
Increments the
to
value by an amount equal to the value ofthat
 that
Quantity

def
includes(that: QuantityRange[A]): Boolean
Returns true if
that
range is completely included inthis
range, otherwise falseReturns true if
that
range is completely included inthis
range, otherwise false that
QuantityRange[A]

def
includes(q: A): Boolean
Returns true if
that
quantity is included withinthis
rangeReturns true if
that
quantity is included withinthis
range q
Quantity

final
def
isInstanceOf[T0]: Boolean
 Definition Classes
 Any
 val lower: A

def
map[B](divisor: Double)(op: (QuantityRange[A]) ⇒ B): Seq[B]
Divides the range into a Seq of
divisor
ranges and applies a map operation to eachDivides the range into a Seq of
divisor
ranges and applies a map operation to each B
the result type of the map operation
 divisor
Quantity representing the size for each QuantityRange in the Seq
 op
the transformation operation

def
map[B](size: A)(op: (QuantityRange[A]) ⇒ B): Seq[B]
Divides the range into a Seq of ranges of
size
each and applies a map operation to eachDivides the range into a Seq of ranges of
size
each and applies a map operation to each B
the result type of the map operation
 size
Quantity representing the size for each QuantityRange in the Seq
 op
the transformation operation

final
def
ne(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

final
def
notify(): Unit
 Definition Classes
 AnyRef

final
def
notifyAll(): Unit
 Definition Classes
 AnyRef

def
partiallyContains(range: QuantityRange[A]): Boolean
Returns true if
that
range contains any part that is inthis
range, otherwise falseReturns true if
that
range contains any part that is inthis
range, otherwise false range
QuantityRange[A]

def
partiallyIncludes(range: QuantityRange[A]): Boolean
Returns true if
that
range includes any part that is inthis
range, otherwise falseReturns true if
that
range includes any part that is inthis
range, otherwise false range
QuantityRange[A]

final
def
synchronized[T0](arg0: ⇒ T0): T0
 Definition Classes
 AnyRef

def
times(multiple: Double): QuantitySeries[A]
Create a Seq of
multiple
ranges equal in size to the original with sequential range values Ifmultiple
contains a fractional component, the last item in the resulting range will be equal to that fraction of the originalCreate a Seq of
multiple
ranges equal in size to the original with sequential range values Ifmultiple
contains a fractional component, the last item in the resulting range will be equal to that fraction of the original multiple
Number of ranges to create

lazy val
toList: List[A]
Return this Range's boundary values as List[A] or the two

lazy val
toQuantity: A
Returns a quantity that is equal to the difference between the
from
andto

lazy val
toSeq: Seq[A]
Returns this Range's boundary values as a Seq[A] of the two
 val upper: A

final
def
wait(): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long, arg1: Int): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )