/** File "SynonymsISR.scala", by KWR for CSE250, Spring 2022 Client for tests involving Samuel Fallows's 1898 book of synonyms and antonyms. Uses the ISR library with interchangeable implementations. So far releasing: SortedSLL, SortedDLL (both sloooow), SortedArray (fastest), BALBOA, BALBOADLL (similar) REQUIRES compiled versions of these classes in same folder, plus ISR and Cardbox */ import io.StdIn._ import io.Source import java.io.File //technically not needed import java.io.FileWriter //makes it easy to append import java.io.PrintWriter //makes "print" and "println" available import scala.collection.mutable.ArrayBuffer //import ISR._ //still don't have packages working on Autograder... :-( object SpeechParts extends Enumeration { //type SpeechPart = Value val Adjective, Noun, Verb, Misc, Unknown = Value } /** Assignment 4 class changed to have a part-of-speech field INV: category is one of "noun", "verb", "adjective", or "misc" (or "unknown") */ case class SynonymEntry(key: String, kind: SpeechParts.Value, synonyms: StringBox) //Use ISR classes for *both* the individual synonym lists *and* the whole book //class StringBox extends Cardbox[String]((x,y) => x.compareTo(y)) class StringBox extends Cardbox[String](13, x=>x.hashCode, (x,y) => x==y) //class SynonymBox(comp: (SynonymEntry,SynonymEntry) => Int) extends Cardbox[SynonymEntry](comp) //class SynonymBox extends Cardbox[SynonymEntry]((x,y) => x.key.compareTo(y.key)) //class SynonymBox extends Cardbox[SynonymEntry](10009, x=>x.key.hashCode, (x,y) => (x.key==y.key && x.kind==y.kind)) class SynonymBox extends Cardbox[SynonymEntry](100, x=>x.key.hashCode, (x,y) => (x.key==y.key)) /** Principal lines begin "KEY: " and "SYN: ", the latter possibly followed by similar lines with no headword and terminated by a line beginning "ANT:" or with "=". Assume words of those lines begin in column 5. Reader uses state pattern to work one line at a time. SAME as in the Map-based answer key, except for 2 lines as noted. */ object SynonymReader { def readEntries: ArrayBuffer[SynonymEntry] = { val synFile = "Fallows1898fx.txt" val src = Source.fromFile(synFile) var synarray = new ArrayBuffer[SynonymEntry]() var key = "" var inSyn = false var accumeLine = "" var count = 0 var kind = SpeechParts.Unknown for (line <- src.getLines()) { if (line.startsWith("KEY:")) { if (key != "" || inSyn) { println("Parse off rails at " + line) } val restLine = line.substring(5) var inAlpha = true for (c <- restLine if inAlpha) { if (c.isLetter || c == '_' || c == '-') { key += c } else { inAlpha = false } } if (key != "") { key = key.toLowerCase if (line.contains("\\n.\\")) { //println("Added noun from line " + line) kind = SpeechParts.Noun } else if (line.contains("\\v.\\")) { //println("Added verb from line " + line) kind = SpeechParts.Verb } else if (line.contains("\\a.\\")) { //println("Added adjective from line " + line) kind = SpeechParts.Adjective } else if (line.contains("\\r.\\")) { //println("Added adjective from line " + line) kind = SpeechParts.Misc } //if (key.startsWith("wage")) { println(key) } } } else if (line.startsWith("SYN:")) { if (key == "") { println("No key found for synonyms beginning " + line) } else if (inSyn) { println("Parse off rails at " + key + ":" + line) } inSyn = true accumeLine = line.substring(5) } else if (line.startsWith("ANT:") || line.startsWith("=")) { if (inSyn && key != "") { accumeLine = accumeLine.trim() if (accumeLine.endsWith(".")) { accumeLine = accumeLine.dropRight(1) } val syns = accumeLine.split(",\\s+") if (syns.size > 0) { //val item = new SynonymEntry(key, Set[String]()) //val item = SynonymEntry(key, SortedSet[String]()) //val item = SynonymEntry(key, ListBuffer[String]()) //ONLY CHANGES are here. Need "insert" not "+=" to keep sortedness. val item = SynonymEntry(key, kind, new StringBox()) for (word <- syns) { //item.synonyms += (word.toLowerCase) item.synonyms.insert(word.toLowerCase) } synarray :+= item count += 1 if (count % 1000 == 0) { println(s"Entry $count is ${item.key}:" + item.synonyms.toList) } } else { println("Empty synonym list found for key " + key) } } key = "" inSyn = false accumeLine = "" kind = SpeechParts.Unknown } else if (inSyn) { accumeLine += " " + line } else { //do nothing } } return synarray } } object SynonymsISR extends App { val outp = new PrintWriter(new FileWriter("output.txt",true)); //appends def keyComp(x: SynonymEntry, y: SynonymEntry) = x.key.compareTo(y.key) var synarray = SynonymReader.readEntries println("Created " + synarray.length + " entries.") synarray = scala.util.Random.shuffle(synarray) println("Shuffled " + synarray.length + " entries.") val lookup = new SynonymBox() var count = 0 val ms = 1000000.0 val allowPrintWhenTiming = true println("\n\n\n\n") println("Timing the creation of the SynonymsBox, reading simple entries from array...") if (allowPrintWhenTiming) { println("...allowing printing to screen & file. Note: twenty inserts put in duplicate keys...") println("...because Fallows1898.txt has 20 buggy repeated entries of words, clearly typos...\n") } val tm1 = System.nanoTime() for (item <- synarray) { count = lookup.size //lookup(item.key) = item.synonyms //lookup += (item.key -> item.synonyms) lookup.insert(item) if (lookup.size == count && allowPrintWhenTiming) { println("SynonymBox did not increase when adding " + item.key + ": " + item.synonyms.toList) } if (count % 1000 == 0 && allowPrintWhenTiming) { println(s"SynonymBox item $count is ${item.key}:" + item.synonyms.toList) } } val h = new Heap[SynonymEntry](10000, (x,y) => x.key.compareTo(y.key)) h.fromArray(synarray.toArray) lookup.fromSortedArray(h.toSortedArray) val tm2 = System.nanoTime() var elapsedTime = (tm2 - tm1)/ms println("") println("SynonymBox creation took time " + elapsedTime + " ms, from " + lookup.size + " different entries") println("Iterating finds " + lookup.toList.size + " entries") println("\n\n\n\n") /** Needed because "find" etc. take a whole item, not just its key. But it can be a dummy item in fields that aren't used for keys. Note that "null.asInstanceOf[StringBox]" is OK even when StringBox is a case class. */ //def dummyEntry(key: String) = new SynonymEntry(key, new StringBox()) //def dummyEntry(key: String) = new SynonymEntry(key, null.asInstanceOf[StringBox]) def dummyEntry(key: String) = new SynonymEntry(key, SpeechParts.Unknown, new StringBox()) println("\nTiming the main run now..." + (if (allowPrintWhenTiming) "" else "no printing...") + "\n") val t1 = System.nanoTime() var keyitr = lookup.begin while (keyitr.hasNext) { val entry = keyitr.next() val key = entry.key //TASK: For each synonym "word" of key, lookup word and see if key is val synSet = entry.synonyms //one of word's own synonyms. Because word might appear in different var synitr = synSet.begin //noun,verb,adj., etc. forms, we have to try multiple keys. var recip = false var hasSyns = false while (synitr.hasNext) { val word = synitr.next() val wordAsItem = dummyEntry(word) var worditr = lookup.find(wordAsItem) //while (worditr.hasNext && keyComp(wordAsItem,worditr()) == 0) { while (worditr.hasNext && word.compareTo(worditr().key) == 0) { recip = recip || worditr().synonyms.contains(key) hasSyns = hasSyns || (worditr().synonyms.size > 0) worditr.next() } if (allowPrintWhenTiming) { if (recip && key.startsWith("q")) { outp.println(s"$key and $word are reciprocal synonyms (key = " + entry.kind + ")") //println(s"$key and $word are reciprocal synonyms"+tag) } else if ((!recip) && hasSyns && key.startsWith("q")) { outp.println(s"$key lists $word but $word has a list of synonyms without $key") //println(s"$key lists $word but $word has a list of synonyms without $key") } else if (key.startsWith("q")) { //println(s"$key lists $word but that is not a key") } } recip = false hasSyns = false } } val t2 = System.nanoTime() elapsedTime = (t2 - t1)/ms println(s"Elapsed time in milliseconds: $elapsedTime") outp.close() }
