summaryrefslogtreecommitdiff
path: root/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala
diff options
context:
space:
mode:
Diffstat (limited to 'test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala')
-rw-r--r--test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala562
1 files changed, 0 insertions, 562 deletions
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala
deleted file mode 100644
index 9300851b5f..0000000000
--- a/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/SequentialOps.scala
+++ /dev/null
@@ -1,562 +0,0 @@
-package scala.collection.parallel.benchmarks.parallel_array
-
-
-
-trait SequentialOps[T] {
-
- var arr: Array[Any] = null
-
- def sequentialReduce(op: (T, T) => T, sz: Int, init: T) = {
- var i = 0
- val until = sz
- var sum = init
- while (i < until) {
- sum = op(sum, arr(i).asInstanceOf[T])
- i += 1
- }
- sum
- }
-
- def sequentialScan(z: T, op: (T, T) => T, sz: Int) = {
- var outarr = new Array[Any](sz + 1)
- outarr(0) = z
- var last = z
- var i = 0
- var j = 1
- val until = sz
- while (i < until) {
- last = op(last, arr(i).asInstanceOf[T])
- outarr(j) = last
- i += 1
- j += 1
- }
- }
-
- def sequentialCount(pred: T => Boolean, sz: Int) = {
- var i = 0
- val until = sz
- var sum = 0
- while (i < until) {
- if (pred(arr(i).asInstanceOf[T])) sum += 1
- i += 1
- }
- sum
- }
-
- def sequentialForeach[U](f: T => U, sz: Int) = {
- var i = 0
- val until = sz
- var sum = 0
- while (i < until) {
- f(arr(i).asInstanceOf[T])
- i += 1
- }
- }
-
- def sequentialSum[U >: T](sz: Int)(implicit num: Numeric[U]) = {
- var i = 0
- val until = sz
- var sum = num.zero
- while (i < until) {
- sum = num.plus(sum, arr(i).asInstanceOf[T])
- i += 1
- }
- sum
- }
-
- def sequentialMin[U >: T](sz: Int)(implicit ord: Ordering[U]) = {
- var i = 1
- val until = sz
- var min = arr(0).asInstanceOf[U]
- while (i < until) {
- val elem = arr(i).asInstanceOf[U]
- if (ord.lt(elem, min)) min = elem
- i += 1
- }
- min
- }
-
- def sequentialForall(pred: T => Boolean, sz: Int) = {
- var i = 0
- val until = sz
- var all = true
- while (i < until) {
- if (pred(arr(i).asInstanceOf[T])) i += 1
- else {
- all = false
- i = until
- }
- }
- all
- }
-
- def sequentialExists(pred: T => Boolean, sz: Int) = {
- var i = 0
- val until = sz
- var some = false
- while (i < until) {
- if (pred(arr(i).asInstanceOf[T])) {
- some = true
- i = until
- } else i += 1
- }
- some
- }
-
- def sequentialFind(pred: T => Boolean, sz: Int) = {
- var i = 0
- val until = sz
- var opt: Option[T] = None
- while (i < until) {
- if (pred(arr(i).asInstanceOf[T])) {
- opt = Some(arr(i).asInstanceOf[T])
- i = until
- } else i += 1
- }
- opt
- }
-
- def sequentialFilter(pred: T => Boolean, sz: Int) = {
- var i = 0
- val buff = new collection.mutable.ArrayBuffer[T]
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (pred(elem)) buff += elem
- i += 1
- }
- val resarr = new Array[Any](buff.size)
- buff.copyToArray(resarr, 0)
- resarr
- }
-
- def sequentialPartition(pred: T => Boolean, sz: Int) = {
- var i = 0
- val btrue = new collection.mutable.ArrayBuffer[T]
- val bfalse = new collection.mutable.ArrayBuffer[T]
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (pred(elem)) btrue += elem
- else bfalse += elem
- i += 1
- }
- val restrue = new Array[Any](btrue.size)
- val resfalse = new Array[Any](bfalse.size)
- btrue.copyToArray(restrue, 0)
- bfalse.copyToArray(resfalse, 0)
- (restrue, resfalse)
- }
-
- def sequentialTakeOpt(n: Int, sz: Int) = {
- var i = 0
- val until = if (n < sz) n else sz
- val res = new Array[Any](until)
- Array.copy(arr, 0, res, 0, until)
-// while (i < until) {
-// res(i) = arr(i)
-// i += 1
-// }
- res
- }
-
- def sequentialTake(n: Int, sz: Int) = {
- var i = 0
- val b = new collection.mutable.ArrayBuffer[T]
- val until = if (n < sz) n else sz
- b.sizeHint(until)
- while (i < until) {
- val elem = arr(i).asInstanceOf[T]
- b += elem
- i += 1
- }
- val res = new Array[Any](n)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialDrop(n: Int, sz: Int) = {
- var i = n
- val b = new collection.mutable.ArrayBuffer[T]
- b.sizeHint(sz - n)
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- b += elem
- i += 1
- }
- val res = new Array[Any](n)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialSlice(from: Int, until: Int, sz: Int) = {
- var i = from
- val b = new collection.mutable.ArrayBuffer[T]
- b.sizeHint(until - from)
- while (i < until) {
- val elem = arr(i).asInstanceOf[T]
- b += elem
- i += 1
- }
- val res = new Array[Any](until - from)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialSplitAtOpt(n: Int, sz: Int) = {
- var i = 0
- val before = new Array[Any](n)
- val after = new Array[Any](sz - n)
- Array.copy(arr, 0, before, 0, n)
- Array.copy(arr, n, after, 0, sz - n)
- (before, after)
- }
-
- def sequentialSplitAt(n: Int, sz: Int) = {
- var i = 0
- val before = new collection.mutable.ArrayBuffer[T]
- before.sizeHint(n)
- val after = new collection.mutable.ArrayBuffer[T]
- after.sizeHint(sz - n)
- while (i < sz) {
- if (i < n) before += arr(i).asInstanceOf[T]
- else after += arr(i).asInstanceOf[T]
- i += 1
- }
- val resbef = new Array[Any](n)
- val resaft = new Array[Any](sz - n)
- before.copyToArray(resbef, 0)
- after.copyToArray(resaft, 0)
- (resbef, resaft)
- }
-
- def sequentialTakeWhile(p: T => Boolean, sz: Int) = {
- var i = 0
- val b = new collection.mutable.ArrayBuffer[T]
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (p(elem)) {
- b += elem
- i += 1
- } else i = sz
- }
- val res = new Array[Any](sz)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialSpan(p: T => Boolean, sz: Int) = {
- val bpref = new collection.mutable.ArrayBuffer[T]
- val brest = new collection.mutable.ArrayBuffer[T]
- var i = 0
- var prefix = true
- var pos = sz
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (prefix) {
- if (p(elem)) bpref += elem
- else {
- pos = i
- prefix = false
- brest += elem
- }
- } else brest += elem
- i += 1
- }
- val respref = new Array[Any](pos)
- val resrest = new Array[Any](sz - pos)
- bpref.copyToArray(respref, 0)
- brest.copyToArray(resrest, 0)
- (respref, resrest)
- }
-
- def sequentialMap(f: T => T, sz: Int) = {
- val b = new collection.mutable.ArrayBuffer[T](sz)
-
- var i = 0
- while (i < sz) {
- b += f(arr(i).asInstanceOf[T])
- i += 1
- }
-
- val res = new Array[Any](sz)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialMapOpt(f: T => T, sz: Int) = {
- val res = new Array[Any](sz)
-
- var i = 0
- while (i < sz) {
- res(i) = f(arr(i).asInstanceOf[T])
- i += 1
- }
-
- res
- }
-
- def sequentialPartialMap(f: PartialFunction[T, T], sz: Int) = {
- val b = new collection.mutable.ArrayBuffer[T](sz)
-
- var i = 0
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (f.isDefinedAt(elem)) b += f(elem)
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialFlatMap(f: T => Traversable[Int], sz: Int) = {
- val b = new collection.mutable.ArrayBuffer[Int](sz)
-
- var i = 0
- while (i < sz) {
- val ts = f(arr(i).asInstanceOf[T])
- for (elem <- ts) b += elem
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialCopyToArray(destarr: Array[Any], pos: Int, sz: Int) = {
- Array.copy(arr, 0, destarr, pos, sz)
- }
-
- def sequentialSegmentLength(pred: T => Boolean, from: Int, sz: Int) = {
- var i = from
- var cnt = 0
-
- while (i < sz) {
- if (pred(arr(i).asInstanceOf[T])) {
- cnt += 1
- i += 1
- } else i = sz
- }
-
- cnt
- }
-
- def sequentialIndexWhere(pred: T => Boolean, from: Int, sz: Int) = {
- var i = from
- var pos = -1
-
- while (i < sz) {
- if (pred(arr(i).asInstanceOf[T])) {
- pos = i
- i = sz
- } else i += 1
- }
-
- pos
- }
-
- def sequentialLastIndexWhere(pred: T => Boolean, end: Int, sz: Int) = {
- var i = end
- var pos = -1
-
- while (i >= 0) {
- if (pred(arr(i).asInstanceOf[T])) {
- pos = i
- i = -1
- } else i -= 1
- }
-
- pos
- }
-
- def sequentialReverse(sz: Int) = {
- val res = new Array[Any](sz)
-
- var i = sz - 1
- var j = 0
- while (i >= 0) {
- res(j) = arr(i)
- i -= 1
- j += 1
- }
- res
- }
-
- def sequentialReverseMap(f: T => T, sz: Int) = {
- val res = new Array[Any](sz)
-
- var i = sz - 1
- var j = 0
- while (i >= 0) {
- res(j) = f(arr(i).asInstanceOf[T])
- i -= 1
- j += 1
- }
- res
- }
-
- def sequentialSameElements(sq: Seq[T], sz: Int): Boolean = {
- if (sz != sq.length) false
- else {
- var i = 0
- val jt = sq.iterator
- while (i < sz) {
- if (arr(i) == jt.next) i += 1
- else i = sz + 1
- }
- if (i == sz) true
- else false
- }
- }
-
- def sequentialCorresponds(sq: Seq[T], f: (T, T) => Boolean, sz: Int): Boolean = {
- if (sz != sq.length) false
- else {
- var i = 0
- val jt = sq.iterator
- while (i < sz) {
- if (f(arr(i).asInstanceOf[T], jt.next)) i += 1
- else i = sz + 1
- }
- if (i == sz) true
- else false
- }
- }
-
- def sequentialDiff(sq: Seq[T], sz: Int) = {
- val occmap = occurrences(sq)
- val b = new collection.mutable.ArrayBuffer[T]
-
- var i = 0
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (occmap(elem) == 0) b += elem
- else occmap(elem) -= 1
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialIntersect(sq: Seq[T], sz: Int) = {
- val occmap = occurrences(sq)
- val b = new collection.mutable.ArrayBuffer[T]
-
- var i = 0
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- val num = occmap(elem)
- if (num > 0) {
- b += elem
- occmap(elem) = num - 1
- }
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- private def occurrences(sq: Seq[T]) = {
- val occmap = new collection.mutable.HashMap[T, Int] { override def default(k: T) = 0 }
- for (elem <- sq.iterator) occmap(elem) += 1
- occmap
- }
-
- def sequentialRemoveDuplicates(sz: Int) = {
- val occ = new collection.mutable.HashSet[T]
- val b = new collection.mutable.ArrayBuffer[T]
-
- var i = 0
- while (i < sz) {
- val elem = arr(i).asInstanceOf[T]
- if (!occ.contains(elem)) {
- b += elem
- occ.add(elem)
- }
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialPatch(from: Int, p: Seq[T], replaced: Int, sz: Int) = {
- val b = new collection.mutable.ArrayBuffer[T]
- b.sizeHint(from + (sz - from - replaced) + p.size)
-
- var i = 0
- while (i < from) {
- b += arr(i).asInstanceOf[T]
- i += 1
- }
-
- val jt = p.iterator
- while (jt.hasNext) b += jt.next
-
- val skipto = from + replaced
- while (i < from + replaced) i += 1
-
- while (i < sz) {
- b += arr(i).asInstanceOf[T]
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
- def sequentialPadTo(tosize: Int, elem: T, sz: Int) = {
- val b = new collection.mutable.ArrayBuffer[T]
- b.sizeHint(tosize)
-
- var i = 0
- while (i < sz) {
- b += arr(i).asInstanceOf[T]
- i += 1
- }
-
- while (i < tosize) {
- b += elem
- i += 1
- }
-
- val res = new Array[Any](b.size)
- b.copyToArray(res, 0)
- res
- }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-06 19:31:29 +0000