pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:3c7ac7836e4f
+:e86add5a6961
 // some alterative syntax for lists
 1 :: 2 :: 3 :: Nil
 List(1, 2, 3) ::: List(4, 5, 6)
+// also
+List(1, 2, 3) ++ List(4, 5, 6)
 // Equality in Scala is structural
 //=================================
 val a = "Dave"
 val b = "Dave"
 val n1 = 3 + 7
 val n2 = 5 + 5
 n1 == n2
-// this applies to "concrete" values;
+// this applies to "concrete" values...pretty much everything;
-// you cannot compare functions
+// but for example you cannot compare functions (later)
 // Printing/Strings
 //==================
 List(1,2,3,1).toSet
 "hello".toList.tail
 1.toDouble
+1L
+// a long
 // useful list methods
 List(1,2,3,4).length
 List(1,2,3,4).reverse
 def silly(n: Int) : Int = {
 if (n < 10) n * n
 else n + n
 }
-def another_silly(x: Int, y: String) : String = {
-if (x <= 12) y
-else x.toString
-}
-another_silly(2, "two")
-another_silly(12, "twelf")
-another_silly(20, "twenty")
 // If-Conditionals
 //=================
 // - Scala does not have a then-keyword
 // - !both if-else branches need to be present!
 def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
 fact(5)
 fact(150)
 /* boolean operators
 // the same for files
 Try(Some(Source.fromFile("text.txt").mkString)).getOrElse(None)
-// function reading something from files...
+// how to implement a function for reading something from files...
 def get_contents(name: String) : List[String] =
 Source.fromFile(name).getLines.toList
 get_contents("test.txt")
 for ((m, n) <- lst) yield m + n
 for (p <- lst) yield p._1 + p._2
 // general pattern of for-yield
+// (yield can be several lines)
 for (p <- ...) yield {
 // potentially complicated
 // calculation of a result
 }
 // BTW: a roundabout way of printing out a list, say
 val lst = ('a' to 'm').toList
-for (n <- lst) println(n)
 for (i <- (0 until lst.length)) println(lst(i))
 // Why not just? Why making your life so complicated?
 for (c <- lst) println(c)
 // Aside: concurrency
-// (scala <<..parallel_collections...>> -Yrepl-class-based)
+// scala -Yrepl-class-based -cp scala-parallel-collections_2.13-0.2.0.jar
 for (n <- (1 to 10)) println(n)
 import scala.collection.parallel.CollectionConverters._
 for (n <- (1 to 10).par) println(n)
 for (i <- (0 to n)) code
 val end = System.nanoTime()
 (end - start) / 1.0e9
 }
 val list = (1 to 1000000).toList
 time_needed(10, for (n <- list) yield n + 42)
 time_needed(10, for (n <- list.par) yield n + 42)
-val list = (1 to 1000000).toList.map(BigInt(_))
+// ...but par does not make everything faster
 list.sum
 list.par.sum
-list.par.reduce(_ + _)
-list.par.aggregate(BigInt(0))(_ + _, _ + _)
 time_needed(10, list.sum)
 time_needed(10, list.par.sum)
-time_needed(10, list.par.reduce(_ + _))
-time_needed(10, list.par.aggregate(BigInt(0))(_ + _, _ + _))
+// Mutable vs Immutable
+//======================
-// Just for "Fun": Mutable vs Immutable
+//
-//=======================================
+// Remember:
-//
 // - no vars, no ++i, no +=
 // - no mutable data-structures (no Arrays, no ListBuffers)
+// But what the heck....
 // Q: Count how many elements are in the intersections of two sets?
 // A; IMPROPER WAY (mutable counter)
 def count_intersection(A: Set[Int], B: Set[Int]) : Int = {
 var count = 0
-for (x <- A; if (B contains x)) count += 1
+for (x <- A.par; if (B contains x)) count += 1
 count
 }
-val A = (1 to 1000).toSet
+val A = (0 to 999).toSet
-val B = (1 to 1000 by 4).toSet
+val B = (0 to 999 by 4).toSet
 count_intersection(A, B)
 // but do not try to add .par to the for-loop above
 A.par.count(x => B contains x)
 count_intersection2(A, B)
-//another example
+//another bad example
 def test() = {
 var cnt = 0
 for(i <- (1 to 1000000).par) cnt += 1
 println(cnt)
 }
 test()
-//for measuring time
-def time_needed[T](n: Int, code: => T) = {
-val start = System.nanoTime()
-for (i <- (0 to n)) code
-val end = System.nanoTime()
-(end - start) / 1.0e9
-}
-val A = (1 to 1000000).toSet
-val B = (1 to 1000000 by 4).toSet
-time_needed(10, count_intersection(A, B))
-time_needed(10, count_intersection2(A, B))
 // Further Information
 //=====================
 // The Scala homepage and general information is at

changeset 308	e86add5a6961
parent 273	b19227660752
child 310	335079d938aa