pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:2e13dedd922e
+:29781ad780f0
 Set(1,2,3) == Set(3,1,2)
 List(1,2,3) == List(3,1,2)
-// this applies for "concrete" values;
+// this applies to "concrete" values;
 // you cannot compare functions
 // Printing/Strings
 //==================
 println(lst.mkString(", "))
 // some methods take more than one argument
 println(lst.mkString("[", ",", "]"))
 // Conversion methods
 //====================
 List(1,2,3,4,3).indexOf(3)
 "1,2,3,4,5".split(",").mkString("\n")
 "1,2,3,4,5".split(",3,").mkString("\n")
+"abcdefg".startsWith("abc")
 // Types (slide)
-//=======
+//===============
 /* Scala is a strongly typed language
 * some base types
 List[Int],
 Set[Double]
 Pairs: (Int, String)
 List[(BigInt, String)]
+Option[Int]
 */
 // Pairs/Tuples
 val t = (4,1,2,3)
 t._4
+List(("one", 1), ("two", 2), ("three", 3))
 // Function Definitions
 //======================
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 //  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
 //    body
 //  }
+//
+// BTW: no returns!!
+// "last" line (expression) in a function determines the result
+//
+def silly(n: Int) : Int = {
+n * n
+n + n
+}
 // If-Conditionals
 //=================
-// Scala does not have a then-keyword
+// - Scala does not have a then-keyword
-// both if-else branches need to be present
+// - both if-else branches need to be present
 def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
 // Option type
 //=============
 //in Java if something unusually happens, you return null
 //
-//in Scala you use Option
+//in Scala you use Options instead
 //   - if the value is present, you use Some(value)
 //   - if no value is present, you use None
 List(7,2,3,4,5,6).find(_ < 4)
 // the same for files
 Source.fromFile("test.txt").mkString
+// function reading something from files...
+def get_contents(name: String) : List[String] =
+Source.fromFile(name).getLines.toList
+get_contents("test.txt")
+// slightly better - return Nil
+def get_contents(name: String) : List[String] =
+Try(Source.fromFile(name).getLines.toList).getOrElse(Nil)
+get_contents("text.txt")
+// much better - you record in the type that things can go wrong
+def get_contents(name: String) : Option[List[String]] =
+Try(Some(Source.fromFile(name).getLines.toList)).getOrElse(None)
+get_contents("text.txt")
 // String Interpolations
 //=======================
 val n = 3
 println("The square of " + n + " is " + square(n) + ".")
 println(s"The square of ${n} is ${square(n)}.")
+// helpful for debugging purposes
+//
+//         "The most effective debugging tool is still careful thought,
+//          coupled with judiciously placed print statements."
+//                   — Brian W. Kernighan, in Unix for Beginners (1979)
 def gcd_db(a: Int, b: Int) : Int = {
 println(s"Function called with ${a} and ${b}.")
 if (b == 0) a else gcd_db(b, a % b)
 gcd_db(48, 18)
 // Asserts/Testing
-//================
+//=================
 assert(gcd(48, 18) == 6)
 assert(gcd(48, 18) == 5, "The gcd test failed")
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield m * n
 mult_table.sliding(10,10).mkString("\n")
-// the list can also be constructed in any other way
+// the list/set/... can also be constructed in any
+// other way
 for (n <- List(10,12,4,5,7,8,10)) yield n * n
-// with if-predicates
+// with if-predicates / filters
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
 if (n + m) % 2 == 0) yield (n, m)
 for ((m, n) <- lst) yield m + n
 for (p <- lst) yield p._1 + p._2
-// general pattern
+// general pattern of for-yield
-for (x <- ...) yield {
+for (p <- ...) yield {
 // potentially complicated
 // calculation of a result
 }
+// Functions producing multiple outputs
+//======================================
+def get_ascii(c: Char) : (Char, Int) = (c, c.toInt)
+get_ascii('a')
+// .maxBy, sortBy with pairs
+def get_length(s: String) : (String, Int) = (s, s.length)
+val lst = List("zero", "one", "two", "three", "four", "ten")
+val strs = for (s <- lst) yield get_length(s)
+strs.sortBy(_._2)
+strs.sortBy(_._1)
+strs.maxBy(_._2)
+strs.maxBy(_._1)
+// For without yield
+//===================
 // with only a side-effect (no list is produced),
 // has no "yield"
 for (n <- (1 to 10)) println(n)
 // BTW: a roundabout way of printing out a list, say
 val lst = ('a' to 'm').toList
 for (i <- (0 until lst.length)) println(lst(i))
-// why not?
+// Why not just? Why making your life so complicated?
 for (c <- lst) println(c)
 // Aside: concurrency
 // (ONLY WORKS OUT-OF-THE-BOX IN SCALA 2.11.8, not in SCALA 2.12)
 // (would need to have this wrapped into a function, or
 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)
-// Function producing multiple outputs
-//=====================================
+// Just for "Fun": Mutable vs Immutable
+//=======================================
-def get_ascii(c: Char) : (Char, Int) = (c, c.toInt)
+//
+// - no vars, no ++i, no +=
-get_ascii('a')
+// - no mutable data-structures (no Arrays, no ListBuffers)
+// Q: Count how many elements are in the intersections of two sets?
-// .maxBy, sortBy with pairs
-def get_length(s: String) : (String, Int) = (s, s.length)
+def count_intersection(A: Set[Int], B: Set[Int]) : Int = {
+var count = 0
-val lst = List("zero", "one", "two", "three", "four", "ten")
+for (x <- A; if (B contains x)) count += 1
-val strs = for (s <- lst) yield get_length(s)
+count
+}
-strs.sortBy(_._2)
-strs.sortBy(_._1)
+val A = (1 to 1000).toSet
+val B = (1 to 1000 by 4).toSet
-strs.maxBy(_._2)
-strs.maxBy(_._1)
+count_intersection(A, B)
+// but do not try to add .par to the for-loop above
+//propper parallel version
+def count_intersection2(A: Set[Int], B: Set[Int]) : Int =
+A.par.count(x => B contains x)
+count_intersection2(A, B)
+//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 home page and general information is at
+// The Scala homepage and general information is at
 //
 //  http://www.scala-lang.org
 //	http://docs.scala-lang.org
 //
 //
 // It should be fairly easy to install the Scala binary and
-// run Scala on the commandline. There are also at least
+// run Scala on the commandline. People also use Scala with
-// four IDEs you can use with Scala:
+// Vim and Jedit. I currently settled on VS Code
 //
-//  (0) Some general information about setting up IDEs
+//   https://code.visualstudio.com
-//	    with Scala support can be found at
+//
-//
+// There are also plugins for Eclipse and IntelliJ - YMMV.
-//         http://docs.scala-lang.org/getting-started.html
+// Finally there are online editors specifically designed for
-//
+// running Scala applications (but do not blame me if you lose
-//
+// all what you typed in):
-//  (1) Eclipse for Scala (one big bundle)
+//
-//
+//   https://scalafiddle.io
-//         http://scala-ide.org/download/sdk.html
+//   https://scastie.scala-lang.org
 //
-//  (2) IntelliJ (needs additional Plugins)
-//
-//         https://www.jetbrains.com/idea/
-//		   http://docs.scala-lang.org/getting-started-intellij-track/getting-started-with-scala-in-intellij.html
-//
-//  (3) Sublime (not free, but unlimited trial period;
-//	    needs Scala and SublimeREPL plugin)
-//
-//         https://www.sublimetext.com
-//
-//  (4) Emacs (old-fashioned, but reliable)
-//
-//         https://www.gnu.org/software/emacs/
-//
-//      I use the old scala-tool support for Emacs distributed at
-//
-//         https://github.com/scala/scala-tool-support/tree/master/tool-support/emacs
-//
-//      but there is also support for the newer Ensime Scala Mode
-//
-//         http://ensime.org/editors/emacs/scala-mode/
-//
-// There is also Scala support in the Atom editor, but my
-// experience is mixed. People also use Scala with Vim and Jedit.
-// Finally there is an online editor specifically designed for
-// running Scala applications (but do not blame mne if you lose all
-// what you typed in):
-//
-//      https://scalafiddle.io
-//
-//
-//
-// All of the IDEs above support a REPL for Scala. Some of them have
-// the very nifty feature of a Scala Worksheet -- you just save your
-// file and it will be automatically evaluated and the result pasted
-// into your file. However, this way of writing Scala code never worked
-// for me. I just use the REPL.
 //
 //
 // Scala Library Docs
 //====================
 //
 // Scala Tutorials
 //
 //  http://docs.scala-lang.org/tutorials/
 //
 // There are also a massive number of Scala tutorials on youtube
-// and there are tons of books and free material.
+// and there are tons of books and free material. Google is your
-//
+// friend.

changeset 200	29781ad780f0
parent 199	2e13dedd922e
child 202	3b40cc2a938a