#218 setIndex2 and append2 for Doubles methods completed.

Util/src/Arr/Dbl2Elem.scala

@@ -14,8 +14,8 @@ trait Dbl2Elem extends Any with DblNElem
 /** A Sequence like class of [[Dbl2Elem]] elements that can be constructed from 2 [[Double]]s. */
 trait Dbl2SeqLike[A <: Dbl2Elem] extends Any with DblNSeqLike[A]
 { override def elemProdSize: Int = 2
-  override def setElemUnsafe(index: Int, newElem: A): Unit = { unsafeArray(2 * index) = newElem.dbl1; unsafeArray(2 * index + 1) = newElem.dbl2 }
-  override def dblBufferAppend(buffer: ArrayBuffer[Double], elem: A) : Unit = { buffer.append(elem.dbl1); buffer.append(elem.dbl2) }
+  override def setElemUnsafe(index: Int, newElem: A): Unit = unsafeArray.setIndex2(index, newElem.dbl1, newElem.dbl2)
+  override def dblBufferAppend(buffer: ArrayBuffer[Double], elem: A) : Unit = buffer.append2(elem.dbl1, elem.dbl2)
 }
 
 /** A sequence-defined specialised immutable, flat Array[Double] based trait defined by a sequence of a type of [[Dbl2Elem]]s. */
@@ -95,8 +95,7 @@ trait Dbl2Arr[A <: Dbl2Elem] extends Any with DblNArr[A] with Dbl2SeqLike[A]
   @targetName("append") inline final override def +%(operand: A): ThisT =
   { val newArray = new Array[Double](unsafeLength + 2)
     unsafeArray.copyToArray(newArray)
-    newArray(unsafeLength) = operand.dbl1
-    newArray(unsafeLength + 1) = operand.dbl2
+    newArray.setIndex2(length, operand.dbl1, operand.dbl2)
     fromArray(newArray)
   }
 
@@ -112,7 +111,7 @@ trait Dbl2SeqLikeCommonBuilder[BB <: Dbl2SeqLike[_]] extends DblNSeqLikeCommonBu
 
 trait Dbl2SeqLikeMapBuilder[B <: Dbl2Elem, BB <: Dbl2SeqLike[B]] extends Dbl2SeqLikeCommonBuilder[BB] with DblNSeqLikeMapBuilder[B, BB]
 { type BuffT <: Dbl2Buff[B]
-  final override def indexSet(seqLike: BB, index: Int, elem: B): Unit = { seqLike.unsafeArray(index * 2) = elem.dbl1; seqLike.unsafeArray(index * 2 + 1) = elem.dbl2}
+  final override def indexSet(seqLike: BB, index: Int, elem: B): Unit = seqLike.unsafeArray.setIndex2(index, elem.dbl1, elem.dbl2)
 }
 
 /** Trait for creating the ArrTBuilder type class instances for [[Dbl2Arr]] final classes. Instances for the [[ArrMapBuilder]] type
@@ -133,12 +132,10 @@ trait Dbl2SeqLikeCompanion[A <: Dbl2Elem, AA <: Dbl2SeqLike[A]] extends DblNSeqL
   def apply(elems: A*): AA =
   { val length = elems.length
     val res = uninitialised(length)
-    var count: Int = 0
-
-    while (count < length)
-    { res.unsafeArray(count * 2) = elems(count).dbl1
-      res.unsafeArray(count * 2 + 1) = elems(count).dbl2
-      count += 1
+    var i: Int = 0
+    while (i < length)
+    { res.unsafeArray.setIndex2(i, elems(i).dbl1, elems(i).dbl2)
+      i += 1
     }
     res
   }
@@ -160,9 +157,9 @@ trait Dbl2Buff[B <: Dbl2Elem] extends Any with DblNBuff[B]
 
   final override def length: Int = unsafeBuffer.length / 2
   final override def elemProdSize: Int = 2
-  final override def grow(newElem: B): Unit = { unsafeBuffer.append(newElem.dbl1).append(newElem.dbl2); () }
+  final override def grow(newElem: B): Unit = unsafeBuffer.append2(newElem.dbl1, newElem.dbl2)
 
   override def apply(index: Int): B = newElem(unsafeBuffer(index * 2), unsafeBuffer(index * 2 + 1))
-  final override def setElemUnsafe(i: Int, newElem: B): Unit = { unsafeBuffer(i * 2) = newElem.dbl1; unsafeBuffer(i * 2 + 1) = newElem.dbl2 }
+  final override def setElemUnsafe(i: Int, newElem: B): Unit = unsafeBuffer.setIndex2(i, newElem.dbl1, newElem.dbl2)
   override def fElemStr: B => String = _.toString
 }

Util/src/Arr/Dbl2PairElem.scala

@@ -1,4 +1,4 @@
-/* Copyright 2018-22 Richard Oliver. Licensed under Apache Licence version 2.0. */
+/* Copyright 2018-23 Richard Oliver. Licensed under Apache Licence version 2.0. */
 package ostrat
 import annotation._, reflect.ClassTag
 
@@ -15,21 +15,22 @@ trait Dbl2PairArr[A1 <: Dbl2Elem, ArrA1 <: Dbl2Arr[A1], A2, A <: Dbl2PairElem[A1
 
   final override def apply(index: Int): A = newPair(a1ArrayDbl(index * 2), a1ArrayDbl(index * 2 + 1), a2Array(index))
 
-  final override def setElemUnsafe(i: Int, newElem: A): Unit = { a1ArrayDbl(i * 2) = newElem.a1Dbl1; a1ArrayDbl(i * 2 + 1) = newElem.a1Dbl2
-    a2Array(i) = newElem.a2 }
+  final override def setElemUnsafe(i: Int, newElem: A): Unit =
+  { a1ArrayDbl.setIndex2(i, newElem.a1Dbl1, newElem.a1Dbl2)
+    a2Array(i) = newElem.a2
+  }
 
   def newA1(dbl1: Double, dbl2: Double): A1
   final override def a1Index(index: Int): A1 = newA1(a1ArrayDbl(index * 3), a1ArrayDbl(index * 3 + 1))
   final override def a1NumDbl: Int = 2
-  final override def setA1Unsafe(index: Int, value: A1): Unit = { a1ArrayDbl(index * 2) = value.dbl1; a1ArrayDbl(index * 2 + 1) = value.dbl2 }
+  final override def setA1Unsafe(index: Int, value: A1): Unit = a1ArrayDbl.setIndex2(index, value.dbl1, value.dbl2)
 
   @targetName("append") final def +%(operand: A)(implicit ct: ClassTag[A2]): ThisT = appendPair(operand.a1, operand.a2)
 
   final def appendPair(a1: A1, a2: A2)(implicit ct: ClassTag[A2]): ThisT =
   { val newA1Array = new Array[Double](a1ArrayLength + 2)
     a1ArrayDbl.copyToArray(newA1Array)
-    newA1Array(a1ArrayLength) = a1.dbl1
-    newA1Array(a1ArrayLength + 1) = a1.dbl2
+    newA1Array.setIndex2(length, a1.dbl1, a1.dbl2)
     val newA2Array = new Array[A2](length + 1)
     a2Array.copyToArray(newA2Array)
     newA2Array(length) = a2
@@ -43,14 +44,12 @@ trait Dbl2PairBuff[A1 <: Dbl2Elem, A2, A <: Dbl2PairElem[A1, A2]] extends DblNPa
   inline final override def apply(index: Int): A = newElem(b1DblBuffer (index * 2), b1DblBuffer(index * 2 + 1), b2Buffer(index))
 
   override final def grow(newElem: A): Unit =
-  { b1DblBuffer.append(newElem.a1Dbl1)
-    b1DblBuffer.append(newElem.a1Dbl2)
+  { b1DblBuffer.append2(newElem.a1Dbl1, newElem.a1Dbl2)
     b2Buffer.append(newElem.a2)
   }
 
   override final def setElemUnsafe(i: Int, newElem: A): Unit =
-  { b1DblBuffer(i * 3) = newElem.a1Dbl1
-    b1DblBuffer(i * 3 + 1) = newElem.a1Dbl2
+  { b1DblBuffer.setIndex2(i, newElem.a1Dbl1, newElem.a1Dbl2)
     b2Buffer(i) = newElem.a2
   }
 }
@@ -61,22 +60,20 @@ trait Dbl2PairArrMapBuilder[B1 <: Dbl2Elem, ArrB1 <: Dbl2Arr[B1], B2, B <: Dbl2P
   override type B1BuffT <: Dbl2Buff[B1]
   final override def a1DblNum: Int = 2
 
-  final override def indexSet(seqLike: ArrB, index: Int, elem: B): Unit = {
-    seqLike.a1ArrayDbl(index * 3) = elem.a1Dbl1
-    seqLike.a1ArrayDbl(index * 3 + 1) = elem.a1Dbl2
+  final override def indexSet(seqLike: ArrB, index: Int, elem: B): Unit =
+  { seqLike.a1ArrayDbl.setIndex2(index, elem.a1Dbl1, elem.a1Dbl2)
     seqLike.a2Array(index) = elem.a2
   }
 }
 
 trait Dbl2PairArrCompanion[A1 <: Dbl2Elem, ArrA1 <: Dbl2Arr[A1]] //extends DblNPairArrCompanion[A1, ArrA1]
 {
   def seqToArrays[A2](pairs: Seq[Dbl2PairElem[_, A2]])(implicit ct: ClassTag[A2]): (Array[Double], Array[A2]) =
-  {  val dblsArray = new Array[Double](pairs.length * 2)
+  { val dblsArray = new Array[Double](pairs.length * 2)
     val a2Array = new Array[A2](pairs.length)
     var i = 0
     pairs.foreach{p =>
-      dblsArray(i * 2) = p.a1Dbl1
-      dblsArray(i * 2 + 1) = p.a1Dbl2
+      dblsArray.setIndex2(i, p.a1Dbl1, p.a1Dbl2)
       a2Array(i) = p.a2
       i += 1
     }

Util/src/Extensions/ArrayExtensions.scala

@@ -1,6 +1,6 @@
 /* Copyright 2018-23 Richard Oliver. Licensed under Apache Licence version 2.0. */
 package ostrat
-import collection.mutable.ArrayBuffer
+import collection.mutable.ArrayBuffer, reflect.ClassTag
 
 /** Extension methods for Array[A] class */
 class ArrayExtensions[A](val thisArray: Array[A]) extends AnyVal
@@ -76,9 +76,8 @@ class ArrayIntExtensions(thisArray: Array[Int])
     System.arraycopy(thisArray, sourceStart, dest, destStart, ife(numElems == -8, dest.length, numElems))
 }
 
-class ArrayBufferIntExtensions(thisBuffer: ArrayBuffer[Int])
-{
-  /** sets 2 elements at 2i and 2i + 1. */
+class BufferIntExtensions(thisBuffer: ArrayBuffer[Int])
+{ /** sets 2 elements at 2i and 2i + 1. */
   @inline def setIndex2(index: Int, i1: Int, i2: Int): Unit = { thisBuffer(index * 2) = i1; thisBuffer(index * 2 + 1) = i2 }
 
   /** sets 3 elements at 3i, 3i + 1, 3i + 2. */
@@ -117,7 +116,35 @@ class ArrayBufferIntExtensions(thisBuffer: ArrayBuffer[Int])
     thisBuffer.append(int3); thisBuffer.append(int4); thisBuffer.append(int5); thisBuffer.append(int6) }
 }
 
-class ArrayBufferDoubleExtensions(thisBuffer: ArrayBuffer[Double])
-{
-  @inline def append2(newElem: Dbl2Elem): Unit = { thisBuffer.append(newElem.dbl1); thisBuffer.append(newElem.dbl2) }
+class ArrayDblExtensions(thisArray: Array[Double])
+{ /** sets 2 elements at 2i and 2i + 1. */
+  def setIndex2(index: Int, d1: Double, d2: Double): Unit = { thisArray(index * 2) = d1; thisArray(index * 2 + 1) = d2 }
+}
+
+class BufferDblExtensions(thisBuffer: ArrayBuffer[Double])
+{ /** sets 2 [[Double]] elements at 2i and 2i + 1. */
+  @inline def setIndex2(index: Int, d1: Double, d2: Double): Unit = { thisBuffer(index * 2) = d1; thisBuffer(index * 2 + 1) = d2 }
+
+  /** Appends 2 [[Double]] elements to this [[ArrayBuffer]][Double]. */
+  @inline def append2(dbl1: Double, dbl2: Double): Unit = { thisBuffer.append(dbl1); thisBuffer.append(dbl2) }
+}
+
+/** Needs Changing. */
+class BufferRefExtensions[A <: AnyRef](thisBuff: ArrayBuffer[A])
+{ /** Converts this ArrayBuffer straight to an [[RArr]]. */
+  @inline def toArr(implicit ct: ClassTag[A]): RArr[A] = new RArr[A](thisBuff.toArray[A])
+
+  def goodRefs(implicit ct: ClassTag[A]): Good[RArr[A]] = Good(new RArr(thisBuff.toArray))
+
+  def toReverseRefs(implicit ct: ClassTag[A]): RArr[A] = {
+    val len = thisBuff.length
+    val acc: Array[A] = new Array[A](len)
+    var count = 0
+
+    while (count < len) {
+      acc(count) = thisBuff(len - 1 - count)
+      count += 1
+    }
+    new RArr(acc)
+  }
 }

Util/src/ostrat/packageOstrat.scala

@@ -510,26 +510,6 @@ package object ostrat
     /** tests if operand is approximately not equal. */
     def !=~(operand: T, precision: D = ev.precisionDefault): Boolean = !ev.approxT(thisT, operand, precision)
   }
-
-  /** Needs Changing. */
-  implicit class RefBufferExtensions[A <: AnyRef](thisBuff: ArrayBuffer[A])
-  { /** Converts this ArrayBuffer straight to an [[RArr]]. */
-    @inline def toArr(implicit ct: ClassTag[A]): RArr[A] = new RArr[A](thisBuff.toArray[A])
-
-    def goodRefs(implicit ct: ClassTag[A]): Good[RArr[A]] = Good(new RArr(thisBuff.toArray))
-
-    def toReverseRefs(implicit ct: ClassTag[A]): RArr[A] =
-    { val len = thisBuff.length
-      val acc: Array[A] = new Array[A](len)
-      var count = 0
-
-      while (count < len)
-      { acc(count) = thisBuff(len - 1 - count)
-        count += 1
-      }
-      new RArr(acc)
-    }
-  }
 
   implicit class ArrayBufferExtensions[A](thisBuff: ArrayBuffer[A])(implicit ct: ClassTag[A])
   { /** If length of this ArrayBuffer is one, perform side effecting function on the sole element. */
@@ -556,7 +536,10 @@ package object ostrat
   implicit def arrayToExtensions[A](array: Array[A]): ArrayExtensions[A] = new ArrayExtensions[A](array)
   implicit def arrayValueNElemToExtensions[A <: ValueNElem](array: Array[A]): ArrayValueNElemExtensions[A] = new ArrayValueNElemExtensions[A](array)
   implicit def arrayIntToExtensions(array: Array[Int]): ArrayIntExtensions = new ArrayIntExtensions(array)
-  implicit def bufferIntToExtensions(array: ArrayBuffer[Int]): ArrayBufferIntExtensions = new ArrayBufferIntExtensions(array)
+  implicit def bufferIntToExtensions(array: ArrayBuffer[Int]): BufferIntExtensions = new BufferIntExtensions(array)
+  implicit def arrayDblToExtensions(array: Array[Double]): ArrayDblExtensions = new ArrayDblExtensions(array)
+  implicit def bufferDblToExtensions(array: ArrayBuffer[Double]): BufferDblExtensions = new BufferDblExtensions(array)
+  implicit def bufferRefToExtensions[A <: AnyRef](array: ArrayBuffer[A]): BufferRefExtensions[A] = new BufferRefExtensions(array)
   implicit def booleanToExtensions(b: Boolean): BooleanExtensions = new BooleanExtensions(b)
   implicit def doubleToExtensions(d: Double): DoubleImplicit = new DoubleImplicit(d)
   implicit def intToExtensions(i: Int): IntExtensions = new IntExtensions(i)