sndyuk/List_add_functioins.scala

## List_add_functioins.scala
import java.io.PrintWriter
import scala.collection.mutable.ListBuffer
import scala.util.{ Try, Success, Failure }

object List_add_functioins extends App {

  //val out = new PrintWriter("score.csv", "utf-8")
  //out.println("""symbol,size,elapsed""") -> For D3js

  def time[R](symbol: String, size: Int, block: => R): R = {
    val limit = 1000 // timeout ms
    val t0 = System.nanoTime()
    val results = (0 until 5).map { n =>
      block
    }

    val t1 = System.nanoTime()
    val elapsed = (t1 - t0) / 1000000
    println(f"${size}%06d > Elapsed time: ${elapsed}%dms")
    //out.println(s"${symbol},${size},${elapsed}")
    if (elapsed > limit) {
      throw new RuntimeException("Timeup.")
    }
    results.head
  }

  def drive[R](id: String, block: Int => R) {
    println(s"------ ${id}")

    Runtime.getRuntime.gc
    Thread.sleep(1000)

    Try((1 to 200001 by 5000).foreach(n => time(id, n, block(n)))) match {
      case Success(v) =>
        println("All done.")
      case Failure(v) =>
        println(v.getMessage)
    }
  }

  drive("List :::", (size: Int) => {

    val actual = (List(0) /: (1 until size)) { (xs, n) =>
      xs ::: List(n)
    }
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("List ::", (size: Int) => {
    val actual = (List(0) /: (1 until size)) { (xs, n) =>
      n :: xs
    }.reverse
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("List ++", (size: Int) => {
    val actual = (List(0) /: (1 until size)) { (xs, n) =>
      xs ++ List(n)
    }
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("List +:", (size: Int) => {
    val actual = (List(0) /: (1 until size)) { (xs, n) =>
      n +: xs
    }.reverse
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("List :+", (size: Int) => {
    val actual = (List(0) /: (1 until size)) { (xs, n) =>
      xs :+ n
    }
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("Buffer +=", (size: Int) => {
    val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
      xs += n
    }
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("Buffer +=:", (size: Int) => {
    val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
      n +=: xs
    }.reverse
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("Buffer ++=", (size: Int) => {
    val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
      xs ++= List(n)
    }
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  drive("ArrayList add", (size: Int) => {
    import scala.collection.JavaConversions._
    import java.util.ArrayList
    val list = new ArrayList[Int]()
    list.add(0)
    val actual = ((list /: (1 until size)) { (xs, n) =>
      xs.add(n)
      xs
    }).toList
    actual.sum
    assume(actual == (0 to size - 1).toList)
  })

  //out.close
}
	import java.io.PrintWriter
	import scala.collection.mutable.ListBuffer
	import scala.util.{ Try, Success, Failure }

	object List_add_functioins extends App {

	//val out = new PrintWriter("score.csv", "utf-8")
	//out.println("""symbol,size,elapsed""") -> For D3js

	def time[R](symbol: String, size: Int, block: => R): R = {
	val limit = 1000 // timeout ms
	val t0 = System.nanoTime()
	val results = (0 until 5).map { n =>
	block
	}

	val t1 = System.nanoTime()
	val elapsed = (t1 - t0) / 1000000
	println(f"${size}%06d > Elapsed time: ${elapsed}%dms")
	//out.println(s"${symbol},${size},${elapsed}")
	if (elapsed > limit) {
	throw new RuntimeException("Timeup.")
	}
	results.head
	}

	def drive[R](id: String, block: Int => R) {
	println(s"------ ${id}")

	Runtime.getRuntime.gc
	Thread.sleep(1000)

	Try((1 to 200001 by 5000).foreach(n => time(id, n, block(n)))) match {
	case Success(v) =>
	println("All done.")
	case Failure(v) =>
	println(v.getMessage)
	}
	}

	drive("List :::", (size: Int) => {

	val actual = (List(0) /: (1 until size)) { (xs, n) =>
	xs ::: List(n)
	}
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("List ::", (size: Int) => {
	val actual = (List(0) /: (1 until size)) { (xs, n) =>
	n :: xs
	}.reverse
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("List ++", (size: Int) => {
	val actual = (List(0) /: (1 until size)) { (xs, n) =>
	xs ++ List(n)
	}
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("List +:", (size: Int) => {
	val actual = (List(0) /: (1 until size)) { (xs, n) =>
	n +: xs
	}.reverse
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("List :+", (size: Int) => {
	val actual = (List(0) /: (1 until size)) { (xs, n) =>
	xs :+ n
	}
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("Buffer +=", (size: Int) => {
	val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
	xs += n
	}
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("Buffer +=:", (size: Int) => {
	val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
	n +=: xs
	}.reverse
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("Buffer ++=", (size: Int) => {
	val actual = (ListBuffer(0) /: (1 until size)) { (xs, n) =>
	xs ++= List(n)
	}
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	drive("ArrayList add", (size: Int) => {
	import scala.collection.JavaConversions._
	import java.util.ArrayList
	val list = new ArrayList[Int]()
	list.add(0)
	val actual = ((list /: (1 until size)) { (xs, n) =>
	xs.add(n)
	xs
	}).toList
	actual.sum
	assume(actual == (0 to size - 1).toList)
	})

	//out.close
	}