PointDbl2PairArr

ostrat.geom.PointDbl2PairArr
trait PointDbl2PairArr[A1 <: PointDbl2, ArrA1 <: ArrDbl2[A1], A2, A <: PointDbl2Pair[A1, A2]] extends PointDblNPairArr[A1, ArrA1, A2, A], PairArrPairDbl2[A1, ArrA1, A2, A]

Attributes

Graph
Supertypes
trait PairArrPairDbl2[A1, ArrA1, A2, A]
trait PointDblNPairArr[A1, ArrA1, A2, A]
trait ArrPairDblN[A1, ArrA1, A2, A]
trait PointPairArr[A1, ArrA1, A2, A]
trait PairArrFinalA1[A1, ArrA1, A2, A]
trait ArrPair[A1, ArrA1, A2, A]
trait Arr[A]
trait Sequ[A]
trait SeqLike[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class LatLongPairArr[A2]
class Pt2PairArr[A2]

Members list

Type members

Types

type ThisT <: PointDbl2PairArr[A1, ArrA1, A2, A]

The final type of this object.

The final type of this object.

Attributes

Value members

Inherited methods

final def +%(operand: A)(implicit ct: ClassTag[A2]): ThisT

Attributes

Inherited from:
PairArrPairDbl2
def a1Arr: ArrA1

Returns the specialist sequence collection for the A1s. Probably not required most of the time but the method is included for completeness.

Returns the specialist sequence collection for the A1s. Probably not required most of the time but the method is included for completeness.

Attributes

Inherited from:
ArrPair

The backing Array for the first elements of the pairs.

The backing Array for the first elements of the pairs.

Attributes

Inherited from:
ArrPairDblN
final def a1ArrayLength: Int

The length of the ArrayDouble backing a1.

The length of the ArrayDouble backing a1.

Attributes

Inherited from:
ArrPairDblN
def a1FindA2(key: A1): Option[A2]

Treats this PairArrFinalA1 as a Map with the A1 values as a the key. Returns None if the key value is absent. If you are certain that this pair sequence contains the A1 key, use the a1GetA2 method.

Treats this PairArrFinalA1 as a Map with the A1 values as a the key. Returns None if the key value is absent. If you are certain that this pair sequence contains the A1 key, use the a1GetA2 method.

Attributes

Inherited from:
ArrPair
def a1GetA2(key: A1): A2

Treats this PairArrFinalA1 as a Map with the A1 values as a the key. Will throw an exception if the given A1 value is not found. If you are uncertain whether this pair sequence contains the A1 key value, use the safe a1FindA2 method.

Treats this PairArrFinalA1 as a Map with the A1 values as a the key. Will throw an exception if the given A1 value is not found. If you are uncertain whether this pair sequence contains the A1 key value, use the safe a1FindA2 method.

Attributes

Inherited from:
ArrPair
final override def a1Index(index: Int): A1

Indexes the first component of the pair.

Indexes the first component of the pair.

Attributes

Definition Classes
Inherited from:
PairArrPairDbl2
def a1Map[B, ArrB <: Arr[B]](f: A1 => B)(implicit builder: BuilderArrMap[B, ArrB]): ArrB

Maps the first component of the pairs, dropping the second.

Maps the first component of the pairs, dropping the second.

Attributes

Inherited from:
ArrPair
final override def a1NumDbl: Int

Attributes

Definition Classes
Inherited from:
PairArrPairDbl2
def a2Arr[A2Arr <: Arr[A2]](implicit build: BuilderArrMap[A2, A2Arr]): A2Arr

Returns the specialist sequence collection for the A2s, as determined by implicit look up. Probably not required most of the time but the method is included for completeness.

Returns the specialist sequence collection for the A2s, as determined by implicit look up. Probably not required most of the time but the method is included for completeness.

Attributes

Inherited from:
ArrPair
def a2Array: Array[A2]

The Array for the A2 components of the pairs. Should be rarely reuired by end user. The a2Arr and the a2RArr methods are generally preferred.

The Array for the A2 components of the pairs. Should be rarely reuired by end user. The a2Arr and the a2RArr methods are generally preferred.

Attributes

Inherited from:
ArrPair
def a2Exists(value: A2): Boolean

Attributes

Inherited from:
ArrPair
def a2FindA1(key: A2): Option[A1]

Treats this PairArrFinalA1 as a Map with the A2 values as a the key. Returns None if the key value is absent. If you are certain that this pair sequence contains the A2 key, use the a2GetA1 method.

Treats this PairArrFinalA1 as a Map with the A2 values as a the key. Returns None if the key value is absent. If you are certain that this pair sequence contains the A2 key, use the a2GetA1 method.

Attributes

Inherited from:
ArrPair
def a2GetA1(key: A2): A1

Treats this PairArrFinalA1 as a Map with the A2 values as a the key. Will throw an exception if the given A2 value is not found. If you are uncertain whether this pair sequence contains the A2 key, use the safe a2FindA1 method.

Treats this PairArrFinalA1 as a Map with the A2 values as a the key. Will throw an exception if the given A2 value is not found. If you are uncertain whether this pair sequence contains the A2 key, use the safe a2FindA1 method.

Attributes

Inherited from:
ArrPair
def a2Index(index: Int): A2

Indexes the second component of the pair.

Indexes the second component of the pair.

Attributes

Inherited from:
ArrPair
def a2IndexFind(key: A2): Option[Int]

Attributes

Inherited from:
ArrPair
def a2IndexGet(value: A2): Int

Attributes

Inherited from:
ArrPair
def a2Map[B, ArrB <: Arr[B]](f: A2 => B)(implicit builder: BuilderArrMap[B, ArrB]): ArrB

Maps the second component of the pairs, dropping the first.

Maps the second component of the pairs, dropping the first.

Attributes

Inherited from:
ArrPair
def a2RArr: RArr[A2]

Returns an RArr of the A2s, even if a better more specialist collection exists for the type. Probably not required most of the time but the method is included for completeness.

Returns an RArr of the A2s, even if a better more specialist collection exists for the type. Probably not required most of the time but the method is included for completeness.

Attributes

Inherited from:
ArrPair
final def appendPair(a1: A1, a2: A2)(implicit ct: ClassTag[A2]): ThisT

Attributes

Inherited from:
PairArrPairDbl2
final override def apply(index: Int): A

Accesses the defining sequence element by a 0 based index.

Accesses the defining sequence element by a 0 based index.

Attributes

Definition Classes
Inherited from:
PairArrPairDbl2
def bestOfGet(init: A)(f1: A => Boolean)(f2: (A, A) => Boolean): A

Attributes

Inherited from:
Sequ
def collect[B, BB <: Arr[B]](pf: PartialFunction[A, B])(implicit ev: BuilderArrMap[B, BB]): BB

Collects values of B by applying partial function to only those elements of A, for which the PartialFunction is defined.

Collects values of B by applying partial function to only those elements of A, for which the PartialFunction is defined.

Attributes

Inherited from:
Sequ
def contains[A1 >: A](elem: A1): Boolean

Returns true if this sequence contains a value equal to the parameter value. The passed vvalue for equivlence testing an be a super type of the collection type.

Returns true if this sequence contains a value equal to the parameter value. The passed vvalue for equivlence testing an be a super type of the collection type.

Attributes

Inherited from:
Sequ
def cycleGet(index: Int): A

Applies an index to this ArrayLike collection which cycles back to element 0, when it reaches the end of the collection. Accepts even negative integers as an index value without throwing an exception.

Applies an index to this ArrayLike collection which cycles back to element 0, when it reaches the end of the collection. Accepts even negative integers as an index value without throwing an exception.

Attributes

Inherited from:
Sequ
override def elemsStr: String

The element String allows the composition of toString for the whole collection. The syntax of the output will be reworked.

The element String allows the composition of toString for the whole collection. The syntax of the output will be reworked.

Attributes

Definition Classes
Inherited from:
Sequ
def empty: Boolean

Is this sequence empty?

Is this sequence empty?

Attributes

Inherited from:
Sequ
def exists(f: A => Boolean): Boolean

Tests if the condition exists for any element of this sequence.

Tests if the condition exists for any element of this sequence.

Attributes

Inherited from:
Sequ
def existsCount(f: A => Boolean): Int

Counts the number of elements that fulfil the condition A => Boolean

Counts the number of elements that fulfil the condition A => Boolean

Attributes

Inherited from:
Sequ
def fElemStr: (A) => String

Attributes

Inherited from:
SeqLike
def fMax[B](defaultValue: B)(f: A => B)(implicit cmp: Ordering[B]): B

Gives the maximum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Gives the maximum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Attributes

Inherited from:
Sequ
def fMin[B](defaultValue: B)(f: A => B)(implicit cmp: Ordering[B]): B

Gives the minimum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Gives the minimum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Attributes

Inherited from:
Sequ
def filter[ArrA <: Arr[A]](f: A => Boolean)(implicit ev: BuilderArrMap[A, ArrA]): ArrA

Attributes

Inherited from:
Sequ
def filterNot[ArrA <: Arr[A]](f: A => Boolean)(implicit ev: BuilderArrMap[A, ArrA]): ArrA

Attributes

Inherited from:
Sequ
def filterOnA1(f: A1 => Boolean)(implicit build: BuilderArrPairMap[A1, ArrA1, A2, A, ThisT]): ThisT

filters this sequence using a predicate upon the A1 components of the pairs.

filters this sequence using a predicate upon the A1 components of the pairs.

Attributes

Inherited from:
ArrPair
def filterToList(f: A => Boolean): List[A]

Attributes

Inherited from:
Sequ
def find(f: A => Boolean): Option[A]

Tries to find te first element of this sequence conforming to the predicate.

Tries to find te first element of this sequence conforming to the predicate.

Attributes

Inherited from:
Sequ
def findGood[B](f: A => EMon[B]): EMon[B]

Takes a function that returns an EMon and returns the first Good.

Takes a function that returns an EMon and returns the first Good.

Attributes

Inherited from:
Sequ
def flatMap[ArrB <: Arr[_]](f: A => ArrB)(implicit ev: BuilderArrFlat[ArrB]): ArrB

Specialised flatMap to a Arr.

Specialised flatMap to a Arr.

Attributes

Inherited from:
Sequ
def flatMapOnA1[B1, ArrB1 <: Arr[B1], ArrB <: PairArrFinalA1[B1, ArrB1, A2, _]](f: A1 => ArrB1)(implicit build: BuilderArrPairFlat[B1, ArrB1, A2, ArrB]): ArrB

Maps each A1 to an Arr[B1] combines each of those new B1s with the same old A2 to produce a PairArrFinalA1 of PairFinalA1Elem[B1, A2]. Then flattens these new PairArrFinalA1s to make a single PairArrFinalA1

Maps each A1 to an Arr[B1] combines each of those new B1s with the same old A2 to produce a PairArrFinalA1 of PairFinalA1Elem[B1, A2]. Then flattens these new PairArrFinalA1s to make a single PairArrFinalA1

Attributes

Inherited from:
ArrPair
def flatToIterableMap[B, ArrB <: Arr[B]](f: A => Iterable[B])(implicit ev: BuilderArrMap[B, ArrB]): ArrB

Maps over a function from A to any Iterable and flattens the result into an RArr[A].

Maps over a function from A to any Iterable and flattens the result into an RArr[A].

Attributes

Inherited from:
Sequ
def foldHeadTail[B](initVal: B)(f: A => B, fAcc: (B, B) => B): B

Attributes

Inherited from:
Sequ
def foldLeft[B](f: (B, A) => B)(implicit ev: DefaultValue[B]): B

Attributes

Inherited from:
Sequ
def foldLeft[B](initial: B)(f: (B, A) => B): B

Folds over this sequence starting with the initial value

Folds over this sequence starting with the initial value

Attributes

Inherited from:
Sequ
def foldStr(f: A => String, seperator: String): String

Folds left to a String accumulator with an initial value of the empty string. The first parameter is a function from A tp String. The second parameter is a separator String the 2nd and subsequent A => String values.

Folds left to a String accumulator with an initial value of the empty string. The first parameter is a function from A tp String. The second parameter is a separator String the 2nd and subsequent A => String values.

Attributes

Inherited from:
Sequ
def forAll(p: A => Boolean): Boolean

Returns true if the predicate holds true for all values of this sequence, else retruns false.

Returns true if the predicate holds true for all values of this sequence, else retruns false.

Attributes

Inherited from:
Sequ
def foreach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

Inherited from:
Sequ
def head: A

The first element of this sequence.

The first element of this sequence.

Attributes

Inherited from:
Sequ
def headFind: Option[A]

Returns the Some of the first element unless the sequence is empty in which case it returns None.

Returns the Some of the first element unless the sequence is empty in which case it returns None.

Attributes

Inherited from:
Sequ
def headFold[B](noHead: => B)(ifHead: A => B): B

Folds over the non existence / existence of a head element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the head element.

Folds over the non existence / existence of a head element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the head element.

Attributes

Inherited from:
Sequ
def headFoldToString[B](noHead: => String): String

Folds over the non existence / existence of a head element. If the sequence is nonEmpty applies toString to head element else returns the noHead parameter string.

Folds over the non existence / existence of a head element. If the sequence is nonEmpty applies toString to head element else returns the noHead parameter string.

Attributes

Inherited from:
Sequ
def headOrNone: Any

Attributes

Inherited from:
Arr
def iFlatMap[ArrB <: Arr[_]](iInit: Int)(f: (Int, A) => ArrB)(implicit build: BuilderArrFlat[ArrB]): ArrB

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

Inherited from:
Sequ
def iFlatMap[ArrB <: Arr[_]](f: (Int, A) => ArrB)(implicit build: BuilderArrFlat[ArrB]): ArrB

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

Inherited from:
Sequ
def iForAll(p: (Int, A) => Boolean): Boolean

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

Inherited from:
Sequ
def iForeach[U](startIndex: Int)(f: (Int, A) => U): Unit

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

Inherited from:
Sequ
def iForeach[U](f: (Int, A) => U): Unit

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

Inherited from:
Sequ
def iMap[B, ArrB <: Arr[B]](startindex: Int)(f: (Int, A) => B)(implicit ev: BuilderArrMap[B, ArrB]): ArrB

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

Inherited from:
Sequ
def iMap[B, ArrB <: Arr[B]](f: (Int, A) => B)(implicit ev: BuilderArrMap[B, ArrB]): ArrB

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. This method should be overridden in sub classes.

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. This method should be overridden in sub classes.

Attributes

Inherited from:
Sequ
def ifHead[U](f: A => U): Unit

if this Sequ is nonEmpty performs the side effecting function on the head. If empty procedure is applied.

if this Sequ is nonEmpty performs the side effecting function on the head. If empty procedure is applied.

Attributes

Inherited from:
Sequ
def indexCycle(index: Int): A

like the apply method accesses the defining sequence element by a 0 based index, but cycles around for indexes less that 0 and equal or greater than index length.

like the apply method accesses the defining sequence element by a 0 based index, but cycles around for indexes less that 0 and equal or greater than index length.

Attributes

Inherited from:
Sequ
def indexMapTo[B, BB <: SeqLike[B]](iFrom: Int, iTo: Int, iStep: Int)(f: A => B)(implicit build: BuilderSeqLikeMap[B, BB]): BB

A map operation on the range of indexed values, where the return type of the SeqLike is explicitly given by the the first parameter.

A map operation on the range of indexed values, where the return type of the SeqLike is explicitly given by the the first parameter.

Attributes

Inherited from:
Sequ
def indexOf(elem: A): Int

Attributes

Inherited from:
Sequ
def indexToForeach[U](iFrom: Int, iTo: Int, iStep: Int)(f: A => U): Unit

Performs a side effecting function on each element of the range of index values for this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of the range of index values for this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

Inherited from:
Sequ
def indexWhere(f: A => Boolean): Int

Return the index of the first element where predicate is true, or -1 if predicate not true forall.

Return the index of the first element where predicate is true, or -1 if predicate not true forall.

Attributes

Inherited from:
Sequ
def initForeach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence excluding the last. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence excluding the last. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

Inherited from:
Sequ
def last: A

The last element of this sequence.

The last element of this sequence.

Attributes

Inherited from:
Sequ
def lastFind: Option[A]

Returns the Some of the last element unless the sequence is empty in which case it returns None.

Returns the Some of the last element unless the sequence is empty in which case it returns None.

Attributes

Inherited from:
Sequ
def lastFold[B](noLast: => B)(ifLast: A => B): B

Folds over the non existence / existence of a last element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the last element.

Folds over the non existence / existence of a last element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the last element.

Attributes

Inherited from:
Sequ
def lenStr: String

Just a handy short cut to give the length of this collection as a string.

Just a handy short cut to give the length of this collection as a string.

Attributes

Inherited from:
Sequ
final override def length: Int

The length of this Sequence. This will have the same value as the dataLength property inherited from SeqLike[A].

The length of this Sequence. This will have the same value as the dataLength property inherited from SeqLike[A].

Attributes

Definition Classes
Inherited from:
ArrPair
def map[B, ArrB <: Arr[B]](f: A => B)(implicit build: BuilderArrMap[B, ArrB]): ArrB

Specialised map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Specialised map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Attributes

Inherited from:
Sequ
def map2To1[B, ArrB <: Arr[B]](f: (A, A) => B)(implicit ev: BuilderArrMap[B, ArrB]): ArrB

map 2 elements of A to 1 element of B. Ignores the last element on a collection of odd numbered length.

map 2 elements of A to 1 element of B. Ignores the last element on a collection of odd numbered length.

Attributes

Inherited from:
Sequ
def mapArray[B](f: A => B)(implicit ct: ClassTag[B]): Array[B]

Maps to an Array.

Maps to an Array.

Attributes

Inherited from:
Sequ
def mapCollectGoods[B, BB <: Arr[B]](f: A => EMon[B])(implicit ev: BuilderArrMap[B, BB]): BB

maps from A to EMon[B], collects the good values.

maps from A to EMon[B], collects the good values.

Attributes

Inherited from:
Sequ
def mapEMon[B, BB](ev: BuilderCollMap[B, BB])(f: A => EMon[B]): EMon[BB]

Map from A => EMon[B]. There is a name overload that implicitly takes a narrower BuilderArrMap as the second parameter list.

Map from A => EMon[B]. There is a name overload that implicitly takes a narrower BuilderArrMap as the second parameter list.

Attributes

Inherited from:
Sequ
def mapEMon[B, ArrB <: Arr[B]](f: A => EMon[B])(implicit ev: BuilderArrMap[B, ArrB]): EMon[ArrB]

Map from A => EMon[B]. implicitly takes a BuilderArrMap. There is a name overload that explicitly takes a more flexible BuilderCollMap as the first parameter list.

Map from A => EMon[B]. implicitly takes a BuilderArrMap. There is a name overload that explicitly takes a more flexible BuilderCollMap as the first parameter list.

Attributes

Inherited from:
Sequ
def mapEMonList[B](f: A => EMon[B]): EMon[List[B]]

Map from A => B, retuening an EMon of List.

Map from A => B, retuening an EMon of List.

Attributes

Inherited from:
Sequ
def mapList[B <: AnyRef](f: A => B): List[B]

maps ValueProduct collection to List

maps ValueProduct collection to List

Attributes

Inherited from:
Sequ
def mapOnA1[B1, ArrB1 <: Arr[B1], B <: PairElem[B1, A2], ArrB <: ArrPair[B1, ArrB1, A2, B]](f: A1 => B1)(implicit build: BuilderArrPairMap[B1, ArrB1, A2, B, ArrB]): ArrB

Maps the sequence of pairs to a new sequence of pairs, but leaving the second component of the pairs unchanged.

Maps the sequence of pairs to a new sequence of pairs, but leaving the second component of the pairs unchanged.

Attributes

Inherited from:
ArrPair
def mapPair[B1, ArrB1 <: Arr[B1], B2, B <: PairFinalA1Elem[B1, B2], ArrB <: PairArrFinalA1[B1, ArrB1, B2, B]](f1: A => B1)(f2: A => B2)(implicit build: BuilderArrPairMap[B1, ArrB1, B2, B, ArrB]): ArrB

Specialised map to an immutable PairArrFinalA1 of B. Applies the supplied function to every element of this sequence.

Specialised map to an immutable PairArrFinalA1 of B. Applies the supplied function to every element of this sequence.

Attributes

Inherited from:
Sequ
def mapTo[B, BB <: SeqLike[B]](build: BuilderSeqLikeMap[B, BB])(f: A => B): BB

A map operation where the return type of the SeqLike is explicitly given by the the second type parameter.

A map operation where the return type of the SeqLike is explicitly given by the the second type parameter.

Attributes

Inherited from:
Sequ
def mapUniqueGood[B](f: A => EMon[B]): EMon[B]

Takes a function from A to EMon[B]. If the function applied to eqch element produces a single Good, it is returned else returns Bad.

Takes a function from A to EMon[B]. If the function applied to eqch element produces a single Good, it is returned else returns Bad.

Attributes

Inherited from:
Sequ
def mapWithAcc[B, ArrB <: Arr[B], C](initC: C)(f: (C, A) => (B, C))(implicit ev: BuilderArrMap[B, ArrB]): ArrB

Attributes

Inherited from:
Sequ
def max[B >: A](implicit ord: Ordering[B]): A

Gives the maximum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Gives the maximum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Attributes

Inherited from:
Sequ
def min[B >: A](implicit ord: Ordering[B]): A

Gives the minimum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Gives the minimum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Attributes

Inherited from:
Sequ
def mkString(separator: String): String

Not sure about this method.

Not sure about this method.

Attributes

Inherited from:
Sequ
def newA1(dbl1: Double, dbl2: Double): A1

Attributes

Inherited from:
PairArrPairDbl2
def newFromArrays(a1Array: Array[Double], a2Array: Array[A2]): ThisT

Attributes

Inherited from:
ArrPairDblN
def newPair(dbl1: Double, dbl2: Double, a2: A2): A

Constructs new pair element from 2 Doubles and a third parameter of type A2.

Constructs new pair element from 2 Doubles and a third parameter of type A2.

Attributes

Inherited from:
PairArrPairDbl2

Is this sequence non empty?

Is this sequence non empty?

Attributes

Inherited from:
Sequ
def optAllMap[B, ArrB <: Arr[B]](f: A => Option[B])(implicit build: BuilderArrMap[B, ArrB]): Option[ArrB]

Takes a map function from A to Option[B] but only returns the [[Arr] of B if all the elements map to a Some. Hence the ArrB if returned will be the same length as this sequence.

Takes a map function from A to Option[B] but only returns the [[Arr] of B if all the elements map to a Some. Hence the ArrB if returned will be the same length as this sequence.

Attributes

Inherited from:
Sequ
def optMap[B, ArrB <: Arr[B]](f: A => Option[B])(implicit build: BuilderArrMap[B, ArrB]): ArrB

Specialised opt map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Specialised opt map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Attributes

Inherited from:
Sequ
def optMapOnA1[B1, ArrB1 <: Arr[B1], B <: PairFinalA1Elem[B1, A2], ArrB <: ArrPair[B1, ArrB1, A2, B]](f: A1 => Option[B1])(implicit build: BuilderArrPairMap[B1, ArrB1, A2, B, ArrB]): ArrB

Takes a function from A1 to Option[B1]. The None results are filtered out the B1 values of the sum are paired with their old corresponding A2 values to make the new pairs of type PairFinalA1Elem[B1, A2]. For an RPairArr return type use the optMapRefOnA1 method.

Takes a function from A1 to Option[B1]. The None results are filtered out the B1 values of the sum are paired with their old corresponding A2 values to make the new pairs of type PairFinalA1Elem[B1, A2]. For an RPairArr return type use the optMapRefOnA1 method.

Attributes

Inherited from:
ArrPair
def optMapRefOnA1[B1, B <: PairFinalA1Elem[B1, A2]](f: A1 => Option[B1])(implicit ct1: ClassTag[B1], ct2: ClassTag[A2]): RPairArr[B1, A2]

Attributes

Inherited from:
ArrPair
def pairFlatMap[ArrB <: Arr[_]](f: (A1, A2) => ArrB)(implicit build: BuilderArrFlat[ArrB]): ArrB

Just a flatMap method that avoids unnecessarily constructing the pairs and takes a function from the components to te parameter type ArrB.

Just a flatMap method that avoids unnecessarily constructing the pairs and takes a function from the components to te parameter type ArrB.

Attributes

Inherited from:
ArrPair
def pairForeach(f: (A1, A2) => Unit): Unit

Attributes

Inherited from:
ArrPair
def pairMap[B, ArrB <: Arr[B]](f: (A1, A2) => B)(implicit builder: BuilderArrMap[B, ArrB]): ArrB

Just a map method that avoids unnecessarily constructing the pairs and takes a function from the components to te parameter type B.

Just a map method that avoids unnecessarily constructing the pairs and takes a function from the components to te parameter type B.

Attributes

Inherited from:
ArrPair
def partition[ArrA <: Arr[A]](f: A => Boolean)(implicit build: BuilderArrMap[A, ArrA]): (ArrA, ArrA)

Attributes

Inherited from:
Sequ
override def replaceA1byA2(key: A2, newValue: A1): ThisT

Returns a copy of this PairArrFinalA1 where the A1 component is replaced for any pairs where the A2 value matches the given parameter. this method treats the PairArrFinalA1 as a Scala Map class with the A2s as the keys and the A1s as the values.

Returns a copy of this PairArrFinalA1 where the A1 component is replaced for any pairs where the A2 value matches the given parameter. this method treats the PairArrFinalA1 as a Scala Map class with the A2s as the keys and the A1s as the values.

Attributes

Definition Classes
Inherited from:
ArrPairDblN
def replaceA1byA2OrAppend(key: A2, newValue: A1)(implicit classTag: ClassTag[A2]): ThisT

Attributes

Inherited from:
PairArrFinalA1

Method for keeping the typer happy when returning this as an instance of ThisT.

Method for keeping the typer happy when returning this as an instance of ThisT.

Attributes

Inherited from:
Sequ
def reverseForeach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence in reverse order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence in reverse order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

Inherited from:
Sequ
def reverseIForeach[U](f: (Int, A) => U): Unit

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

Inherited from:
Sequ
final override def setA1Unsafe(index: Int, value: A1): Unit

Attributes

Definition Classes
Inherited from:
PairArrPairDbl2
final def setA2Unsafe(index: Int, value: A2): Unit

Attributes

Inherited from:
ArrPair
final override def setElemUnsafe(i: Int, newElem: A): Unit

Sets / mutates an element in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Sets / mutates an element in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Attributes

Definition Classes
Inherited from:
PairArrPairDbl2
def setElemsUnsafe(index: Int, elems: A*): Unit

Sets / mutates elements in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Sets / mutates elements in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Attributes

Inherited from:
SeqLike
def sortBy(f: (A, A) => Boolean)(implicit build: BuilderArrMap[A, ThisT]): ThisT

Returns a new Arr sorted from least to greatest. Takes a function detrmining if the first value is greater than the second.

Returns a new Arr sorted from least to greatest. Takes a function detrmining if the first value is greater than the second.

Attributes

Inherited from:
Arr
final inline override def ssForeach[U](f: A => U): Unit

Performs a side effecting function on each element of the specifying sequence in order.

Performs a side effecting function on each element of the specifying sequence in order.

Attributes

Definition Classes
Inherited from:
Sequ
def sum(implicit ev: Sumable[A]): A

Attributes

Inherited from:
Sequ
def sumBy(f: A => Int): Int

Sums aaccumulating the results of the A => Int function.

Sums aaccumulating the results of the A => Int function.

Attributes

Inherited from:
Sequ
def tailForeach[U](f: A => U): Unit

Foreachs over the tail of this sequence. Performs a side effecting function on each element of this sequence excluding the first.

Foreachs over the tail of this sequence. Performs a side effecting function on each element of this sequence excluding the first.

Attributes

Inherited from:
Sequ
def tailfold[B](initial: B)(f: (B, A) => B): B

foldLeft over the tail of this sequence.

foldLeft over the tail of this sequence.

Attributes

Inherited from:
Sequ
def toList: List[A]

Converts this SeqGen to a list.

Converts this SeqGen to a list.

Attributes

Inherited from:
Sequ
override def toString: String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns

a string representation of the object.

Definition Classes
SeqLike -> Any
Inherited from:
SeqLike
def toStrsCommaFold(fToStr: A => String): String

Attributes

Inherited from:
Sequ
def toStrsCommaNoSpaceFold(fToStr: A => String): String

Attributes

Inherited from:
Sequ
def toStrsCommaParenth(fToStr: A => String): String

Attributes

Inherited from:
Sequ
def toStrsSemiFold(fToStr: A => String): String

Attributes

Inherited from:
Sequ
def toStrsSemiParenth(fToStr: A => String): String

Attributes

Inherited from:
Sequ
def toVector: Vector[A]

Attributes

Inherited from:
Sequ

String specifying the type of this object.

String specifying the type of this object.

Attributes

Inherited from:
SeqLike
final override def uninitialised(length: Int)(implicit classTag: ClassTag[A2]): ThisT

Returns a new uninitialised PairArrFinalA1 of the same final type.

Returns a new uninitialised PairArrFinalA1 of the same final type.

Attributes

Definition Classes
Inherited from:
ArrPairDblN
def unsafeSetElemSeq(index: Int, elems: Iterable[A]): Unit

Attributes

Inherited from:
Arr
def unsafeSetHead(value: A): Unit

Sets / mutates the head element in the Arr. This method should rarely be needed by end users, but is used by initialisation and factory methods.

Sets / mutates the head element in the Arr. This method should rarely be needed by end users, but is used by initialisation and factory methods.

Attributes

Inherited from:
Arr
def unsafeSetLast(value: A): Unit

Sets / mutates the last element in the Arr. This method should rarely be needed by end users, but is used by initialisation and factory methods.

Sets / mutates the last element in the Arr. This method should rarely be needed by end users, but is used by initialisation and factory methods.

Attributes

Inherited from:
Arr
def zipMap[B, C, ArrC <: Arr[C]](operator: Sequ[B])(f: (A, B) => C)(implicit ev: BuilderArrMap[C, ArrC]): ArrC

Takes a second collection as a parameter and zips the elements of this collection and the operand collection and applies the specialised map function from type A and type B to type C.

Takes a second collection as a parameter and zips the elements of this collection and the operand collection and applies the specialised map function from type A and type B to type C.

Attributes

Inherited from:
Sequ
def zipMap2[B, C, D, ArrD <: Arr[D]](operator1: Sequ[B], operator2: Sequ[C])(f: (A, B, C) => D)(implicit ev: BuilderArrMap[D, ArrD]): ArrD

Takes a second collection and third collections as parameters and zips the elements of this collection and the operand collections and applies the specialised map function from type A and type B and type C to type D.

Takes a second collection and third collections as parameters and zips the elements of this collection and the operand collections and applies the specialised map function from type A and type B and type C to type D.

Attributes

Inherited from:
Sequ