import scala.actors.Actor
import scala.actors.Actor._
val taskCount = Runtime.getRuntime().availableProcessors()
case class SumPart(items:Array[Int],partCount:Int)
case class CollectSum(sum:Int,partCount:Int)
def randomArray(num:Int):Array[Int] = {
  val result = new Array[Int](num)
  for(i <- 0 to num-1) {
    result(i) = (Math.random() * num).toInt
  }
  result
}
val ReduceActor = actor {
  var result = 0D
  var receiveCount = 0
  loop{
    receive{
      case CollectSum(sum,partCount)=>
        receiveCount += 1
        result += sum
        println(sum)
        if(receiveCount>=partCount){
          result = result/partCount
          println("Actor result:"+result)
          exit()
        }
    }
  }
}
val MapActor = actor{
  loop{
    react{
      case SumPart(items,partCount) =>
        ReduceActor ! CollectSum(items.sum, partCount)
        exit()
    }
  }
}
def actorMain(num:Int, partCount:Int) = {
  val array = randomArray(num)
  val startTime = System.currentTimeMillis()
  var range = 1
  if(array.length>=partCount)
    range = array.length/partCount
  var start = 0
  var end = 0
  var flag = false
  MapActor.start()
  while(!flag){
    if(end+range>=array.length-1){
      end = array.length - 1
      flag = true
    }else{
      end = end+range
    }
    MapActor ! SumPart(array.slice(start,end),partCount)
    start = start+range
  }
  println("Actor cost:"+(System.currentTimeMillis()-startTime))
}
def main(num:Int)={
  val array = randomArray(num)
  val startTime = System.currentTimeMillis()
  println("No-Actor result:"+array.sum/array.length)
  println("No-Actor cost:"+(System.currentTimeMillis()-startTime))
}
for(i<- 1 to 20) {
  actorMain(100000, taskCount)
  actorMain(100000, 100)
}
for(i<- 1 to 20) {
  main(100000)
  main(100000)
}

import java.awt.image.BufferedImage
import java.io.File
import javax.imageio.ImageIO
import scala.actors.Actor
import scala.actors.Actor._
case class InversePart(bufImage:BufferedImage, imageRGB:Array[Int], start:Int, end:Int)
case class WriteImage(result:BufferedImage, imageRGB:Array[Int])
val inputPng = new File("./pic.png")
val outPng = new File("./pic_reverse.png")
class ImageActor(var count:Int = 0) extends Actor{
  override def act()={
    loop{
      react{
        case InversePart(bufImage, imageRGB, start, end) =>
          for(i <- start to end){
            imageRGB(i) = imageRGB(i)^0xffffffff
          }
          self ! WriteImage(bufImage, imageRGB)
        case WriteImage(bufImage, imageRGB) =>
          count -= 1
          if(count==1) {
            val width = bufImage.getWidth
            val height = bufImage.getHeight
            val resultImage = new BufferedImage(bufImage.getWidth, bufImage.getHeight, BufferedImage.TYPE_INT_RGB)
            resultImage.setRGB(0, 0, width, height, imageRGB, 0, width)
            ImageIO.write(resultImage , "png", outPng)
            exit()
          }
      }
    }
  }
}
def inverse = {
  val bufImage = ImageIO.read(inputPng)
  if (bufImage != null) {
    val width = bufImage.getWidth
    val height = bufImage.getHeight
    val imageRGB = new Array[Int](width * height)
    bufImage.getRGB(0, 0, width, height, imageRGB, 0, width)
    var step = 5
    var start = 0
    var end = 0
    var flag = false
    val count = imageRGB.length / step + 1
    val imageActor = new ImageActor(count)
    imageActor.start()
    while (!flag) {
      if (end + step >= imageRGB.length) {
        end = imageRGB.length - 1
        flag = true
      } else {
        end += step
      }
      imageActor ! InversePart(bufImage, imageRGB, start, end)
      start += step
    }
  }
}
inverse

package _1801 {
class Bug(var pos: Int = 0) {
  var forword: Int = 1
  def move(up: Int):this.type = {
    pos += forword * up
    this
  }
  def show():this.type = {
    print(pos + " ")
    this
  }
  def turn():this.type = {
    forword = -forword
    this
  }
}
 class Test extends App {
   val bugsy = new Bug
   bugsy.move(4).show().move(6).show().turn().move(5).show()
 }
}

package _1802 {
  //非动词 non-verb
object then
object show
object around
class Bug(var pos: Int = 0) {
  var forword: Int = 1
  def move(num: Int): this.type = { pos += num; this }
  def and(obj: then.type): this.type = this
  def and(obj: show.type): this.type = { print(pos + " "); this}
  def turn(obj: around.type): this.type = { pos = 0; this}
}
class Test extends App {
  val bugsy = new Bug
  bugsy move 4 and show and then move 6 and show turn around move 5 and show
}
}

class Document {
  var title: String = ""
  var author: String = ""
  def setTitle(title: String):this.type = {this.title = title; this}
  def setAuthor(author: String):this.type = {this.author= author; this}
}
//可枚举
object Title
object Author
class Book extends Document{
  private var useNextArgAs:Any = null
  def set(obj: Any): this.type = {useNextArgAs = obj; this}
  def to(obj:String) = {
    useNextArgAs match{
      case Title => setTitle(obj)
      case Author => setAuthor(obj)
      case _ =>
    }
    this
  }
}
object Main extends App {
  val book = new Book
  book set Title to "Scala for the Impatient" set Author to "Cay Horstmann"
  println(book.title)
  println(book.author)
}

import scala.collection.mutable.ArrayBuffer
class Network {
  class Member(val name: String) {
    val contacts = new ArrayBuffer[Member]
    def canEqual(other: Any): Boolean = other.isInstanceOf[Member]
    override def equals(other: Any): Boolean = other match {
      case that: Member =>
        (that canEqual this) &&
          name == that.name
      case _ => false
    }
  }
  private val members = new ArrayBuffer[Member]
  def join(name: String) = {
    val m = new Member(name)
    members += m
    m
  }
}
val network1 = new Network().join("1")
val network2 = new Network().join("1")
println(network1.equals(network2))

def getIndex(arr: Seq[Int], v: Int): Int Either Int = {
  if (arr.contains(v)) {
    Left(arr.indexOf(v))
  } else {
    Right(arr.indexOf(arr.reduce((a,b) => if (math.abs(v - a) > math.abs(v - b)) b else a)))
  }
}
println(getIndex(Seq(2,3,4,5,-2,-3),1))

def tryWithClose[T<:{def close():Unit}](obj:T,func: T => Unit)={
  try{
    func(obj)
  }finally {
    obj.close()
  }
}

def printValues(f:{def apply(param:Int):Int}, from:Int, to:Int)={
  for(i <- from to to) {
    print(f.apply(i) + " ")
  }
}
printValues((x: Int) => x*x, 3, 6) //将打印 9 16 25 36
printValues(Array(1, 1, 2, 3, 5, 8, 13, 21, 34, 55), 3, 6) //将打印 3 5 8 13

abstract class Dim[T](val value: Double, val name: String){
  this: T =>
  protected def create(v: Double): T
  def + (other: Dim[T]) = create(value + other.value)
  override def toString() = value + " " + name
}
class Seconds(v: Double) extends Dim[Seconds](v, "s"){
  override def create(v: Double) = new Seconds(v)
}
class Meters(v: Double) extends Dim[Seconds](v, "m"){
  override def create(v: Double) = new Seconds(v)
}
//Meters can not extends Dim[Seconds] and compile fail

trait A {
  def sing() = "from a"
}
trait C {
  this: A =>
  val w = sing + "from c"
}
class B{
  this: C =>
  val k = w
}
val b = new B with C with A
println(b.k)

class Pair[T,S](val t:T,val s:S){
  def swap() = new Pair(s,t)
}

class Pair[T](val s:T,val t:T){
  def swap() = new Pair(t,s)
}

class Pair[T,S](val t:T, val s:S){
  def swap[T,S](t:T,s:S) = new Pair(s,t)
}

def middle[T](iter:Iterable[T]):T={
  val seq = iter.toArray
  seq(seq.length/2)
}

//Anyone resolve this, please contact me
package _1709 {
class Pair[+T](val t:T, val s:T) {
  def replaceFirst[T](newFirst: T) {}
}
class NastyDoublePair[Double](t1:Double, s1:Double) extends Pair[Double](t1,s1) {
  override def replaceFirst(newFirst: Double) ={
    /**
     *  error: type mismatch;
       found   : Double(in class NastyDoublePair)
       required: scala.Double
                 new NastyDoublePair(newFirst,math.sqrt(newFirst))
     */
    new NastyDoublePair(newFirst,math.sqrt(newFirst))
  }
}
object test extends App {
  val p: Pair[Any] = new NastyDoublePair(1.0, 2.0)
  p.replaceFirst("Hello")
}
}

class Pair[S,T](val s:S, val t:T){
  def swap(implicit env: S =:= T) = new Pair(t,s)
}

scala> println(<fred/>(0))
<fred/>
scala> println(<fred/>(0)(0))
<fred/>

scala> <ul>
     |   <li>Opening bracket:[</li>
     |   <li>Closing bracket:]</li>
     |   <li>Opening bracket:\{\{</li>
     |   <li>Closing bracket:\}\}</li>
     | </ul>
res9: scala.xml.Elem =
<ul>
  <li>Opening bracket:[</li>
  <li>Closing bracket:]</li>
  <li>Opening bracket:{</li>
  <li>Closing bracket:}</li>
</ul>

import scala.xml.XML
var html = "<html><head><title>第一个网页</title></head><body><p><img alt='a'><img src='1'></img></p></body></html>"
val images = (html \\ "img").filterNot(_.attributes("alt").isDefined)
val images1 = html match{
  case n @ <img/> if (!n.attributes("alt")) => n
}
println(images.mkString("\n"));
println(images1.mkString("\n"));

import scala.xml.XML
var html = "<html><head><title>第一个网页</title></head><body><p><img alt='a'><img src='1'></img></p></body></html>"
val images = (html \\ "img").flatMap(_.attributes("src"))
val images1 = html match{
  case n @ <img/> => Some(n.attributes("src"))
}
println(images.mkString("\n"));
println(images1.mkString("\n"));

import scala.xml._
val html = ""
val links = (html \\ "a") map { (x: Node) => (x.attribute("href").getOrElse("").toString, x.text) } filter {_._1.startsWith("http")}
println(links.mkString("\n"));

def mapToHTML(map: Map[String, String]) = {
  <dl>{for ((k,v) <- map) yield <dt>{k}</dt><dd>{v}</dd>}</dl>
}
val x = Map("A" -> "1", "B" -> "2")
println(mapToHTML(x))

def htmlToMap(str:String):Map[String,String] = {
  val dtMap = (str \\ "dt").toMap
  val ddMap = (str \\ "dd").toMap
  dtMap.zip(ddMap)
}
val html = <dl><dt>A</dt><dd>1</dd><dt>B</dt><dd>2</dd></dl>
println(htmlToMap(html).mkString(","))

import scala.xml._
val html = ""
val replaceNoneAlt = html match{
  case img @ <img/> if(_.attribute(alt)=="NONE") => img % Attribute(null,"alt","TODO",null)
  case _ => html
}
println(replaceNoneAlt)

import xml._
import xml.transform._
import xml.parsing.ConstructingParser
import xml.dtd.DocType
import java.io.File
val doc = ConstructingParser.fromFile(new File("./test.xml"),
  true).document
val a = doc.docElem
val imgRule = new RewriteRule {
  override def transform(n:Node) = n match {
    case i @ <img>{_*}</img> if(i.attribute("alt") == None) =>
      i % Attribute(null, "alt", "TODO", Null)
    case _ => n
  }
}
val result = new RuleTransformer(imgRule).transform(a)
XML.save("./test.xml", result(0), "UTF-8", false,
  DocType("html", doc.dtd.externalID, Nil))

import org.junit.Test
class ScalaTest {
  @Test
  def test1(){
    print("test1")
  }
  @Test(timeout = 1L)
  def test2(){
    print("test2")
  }
}

@deprecated
class Test{
  @deprecated
  val t = _;
  @deprecated(message = "unuse")
  def hello(){
    println("hello")
  }
}
@deprecated
object Test extends App{
  val t = new Test()
  t.hello()
  t.t
}

import scala.annotation.varargs
class Test {
  @varargs def sum(nums: Int*): Int = {
    nums.sum
  }
}
/** Test2.java
class Test2 {
  public static void main(String[] args){
    Test t = new Test();
    System.out.println(t.sum(1,2,3));
  }
}
  **/

import io.Source
class Test5{
  def read()={
    Source.fromFile("test.txt").mkString
  }
}
/*** Test2.java
public class Hello {
  public static void main(String[] args){
    Test5 t = new Test5();
    System.out.println(t.read());
  }
}
  ***/

import concurrent.ops.spawn
object Test06{
  @volatile var value = false
}
spawn {
  Thread.sleep(100);
  Test06.value = true
  println("Thread1: setting value to TRUE!")
}
spawn {
  while(!Test06.value) Thread.sleep(20);
  println("Thread2: value is TRUE!")
}

import annotation.tailrec
object Test extends App{
  @tailrec
  def sum2(xs : Seq[Int],partial : BigInt) : BigInt = {
    if (xs.isEmpty) partial else sum2(xs.tail,xs.head + partial)
  }
  println(sum2(1 to 1000000,0))
}

object Test{
  def allDifferent[@specialized T](x:T,y:T,z:T) = x != y && x!= z && y != z
}

......
trait Function1[@specialized(scala.Int, scala.Long, scala.Float, scala.Double/*, scala.AnyRef*/) -T1, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double/*, scala.AnyRef*/) +R] extends AnyRef { self =>
  /** Apply the body of this function to the argument.
   *  @return   the result of function application.
   */
  def apply(v1: T1): R
......

...... 
@inline final override def foreach[@specialized(Unit) U](f: Int => U) {
    if (validateRangeBoundaries(f)) {
      var i = start
      val terminal = terminalElement
      val step = this.step
      while (i != terminal) {
        f(i)
        i += step
      }
    }
  }
......

object Test {
  def factorial(n: Int): Int = {
    assert(n > 0)
    n
  }
  def main(args: Array[String]) {
    factorial(-1)
  }
}

def swap[S,T](tup: (S,T))={
  tup match{
    case (a,b) => (b,a)
  }
}
println(swap[String,Int](("1",2)))

def swap(array:Array[Any])={
  array match{
    case Array(first,second,rest @_*)=> Array(second,first)++rest
    case _ => array
  }
}
println(swap(Array("1","2","3","4")).mkString)

abstract class Item
case class Multiple(num : Int,item : Item) extends Item
case class Article(description : String , price : Double) extends Item
case class Bundle(description : String , discount : Double , item : Item*) extends Item
def price(it : Item) : Double = it match {
  case Article(_,p) => p
  case Bundle(_,disc,its @ _*) => its.map(price _).sum - disc
  case Multiple(n,it) => n * price(it)
}
val p = price(Multiple(10,Article("Blackwell Toster",29.95)))
println(p)

def leafSum(list:List[Any]):Int={
  var total = 0
  list.foreach {
    lst =>
      lst match {
        case l: List[Any] => total += leafSum(l)
        case i: Int => total += i
      }
  }
  total
}
val l: List[Any] = List(List(3, 8), 2, List(5))
println(leafSum(l))

sealed abstract class BinaryTree
case class Leaf(value : Int) extends BinaryTree
case class Node(left: BinaryTree, right:BinaryTree) extends BinaryTree
def leafSum(tree:BinaryTree):Int={
  tree match {
    case Node(a,b) => leafSum(a) + leafSum(b)
    case Leaf(v) => v
  }
}
val r = Node(Leaf(3),Node(Leaf(3),Leaf(9)))
println(leafSum(r))

sealed abstract class BinaryTree
case class Leaf(value: Int) extends BinaryTree
case class Node(tr: BinaryTree*) extends BinaryTree
def leafSum(tree:BinaryTree):Int={
  tree match {
    case Node(r @_*) => r.map(leafSum).sum
    case Leaf(v) => v
  }
}
val r = Node(Node(Leaf(3), Leaf(8)), Leaf(2), Node(Leaf(5)))
println(leafSum(r))

sealed abstract class BinaryTree
case class Leaf(value: Int) extends BinaryTree
case class Node(op: Char, leafs: BinaryTree*) extends BinaryTree
def eval(tree:BinaryTree):Int= {
  tree match {
    case Node(op, leafs@_*) => op match {
      case '+' => leafs.map(eval _).sum
      case '-' => -leafs.map(eval _).sum
      case '*' => leafs.map(eval _).product
    }
    case Leaf(x) => x
  }
}
  val x = Node('+', Node('*', Leaf(3), Leaf(8)), Leaf(2),  Node('-', Leaf(5)))
  println(x)
  println(eval(x))

def sum(lst: List[Option[Int]]) = lst.map(_.getOrElse(0)).sum
val x = List(Some(1), None, Some(2), None, Some(3))
println(sum(x))

def compose(f:Double=>Option[Double],g:Double=>Option[Double])={
  (x : Double) =>
    if (f(x) == None || g(x) == None) None
    else g(x)
}
import scala.math.sqrt
def f(x : Double) = if ( x >= 0) Some(sqrt(x)) else None
def g(x : Double) = if ( x != 1) Some( 1 / ( x - 1)) else None
val h = compose(f,g)
println(h(2))

def mapStrIndex(str:String)={
  var indexMap = new HashMap[Char,SortedSet[Int]]()
  var i = 0
  str.toCharArray.foreach {
    c =>
      indexMap.get(c) match {
        case Some(result) => indexMap(c) = result + i
        case None => indexMap += (c -> SortedSet {
          i
        })
      }
      i += 1
  }
  indexMap
}
println(mapStrIndex("Mississippi"))

mport scala.collection.mutable.{ListBuffer, HashMap}
def mapStrIndex(str:String)={
  var indexMap = new HashMap[Char,ListBuffer[Int]]()
  var i = 0
  str.toCharArray.foreach {
    c =>
      indexMap.get(c) match {
        case Some(result) => result += i
        case None => indexMap += (c -> ListBuffer {
          i
        })
      }
      i += 1
  }
  indexMap
}
println(mapStrIndex("Mississippi"))

def removeZero(list:List[Int]):List[Int]={
  list.filter(_!=0)
}
println(removeZero(List(3,25,0,2,0,0)))

def filterMap(array:Array[String],map:Map[String,Int]):Array[Int]={
  array.flatMap(map.get(_))
}
println(filterMap(Array("Tom","Fred","Harry"),Map("Tom"->3,"Dick"->4,"Harry"->5)).mkString(","))

import collection.mutable
trait MktString{
  this:mutable.Iterable[String]=>
  def mktString(split:String="") = if( this != Nil) this.reduceLeft(_ + split + _)
}
var test = new mutable.HashSet[String] with MktString
test += "1"
test += "2"
test += "3"
println(test.mktString(","))

val lst = List(1,2,3,4,5)
println((lst :\ List[Int]())(_ :: _))
println((List[Int]() /: lst)(_ :+ _))
println((List[Int]() /: lst)((a,b) => b :: a))

val prices = List(5.0,20.0,9.95)
val quantities = List(10,2,1)
println((prices zip quantities) map { Function.tupled(_ * _) })

def divArr(arr:Array[Double],i:Int)={
  arr.grouped(i).toArray
}
val arr = Array(1.0,2,3,4,5,6)
divArr(arr,3).foreach(a => println(a.mkString(",")))

import scala.collection.immutable.HashMap
val str = "abdcsdcd"
val frequencies = str.par.aggregate(HashMap[Char,Int]())(
  {
    (a,b) =>
      a + (b -> (a.getOrElse(b,0) + 1))
  }
  ,
  {
    (map1,map2) =>
      (map1.keySet ++ map2.keySet).foldLeft( HashMap[Char,Int]() ) {
        (result,k) =>
          result + ( k -> ( map1.getOrElse(k,0 ) + map2.getOrElse(k,0) ) )
      }
  }
)

def values(fun:(Int)=>Int,low:Int,high:Int) ={
  var array = List[(Int,Int)]()
  low to high foreach {
    x =>
      array = (x, fun(x)) :: array
  }
  array
}
println(values(x => x * x, -5, 5).mkString)

val arr = Array(1,333,4,6,4,4,9,32,6,9,0,2)
print(arr.reduceLeft((l,r)=>if(l>=r) l else r))

def factorial(n:Int): Unit ={
  1 to n reduceLeft(_ * _)
}

def factorial(n:Int) = (1 to n).foldLeft(1)(_ * _)
factorial(-3)
factorial(3)

def largest1(fun:(Int)=>Int, inputs:Seq[Int]) = inputs.foldLeft(1)((a,b)=> if(fun(b)>a) fun(b) else a)
def largest2(fun:(Int)=>Int, inputs:Seq[Int]) = inputs.map(fun(_)).max
println(largest1(x => 10 * x - x * x, 1 to 10))
println(largest2(x => 10 * x - x * x, 1 to 10))

def largestAt1(fun:(Int)=>Int, inputs:Seq[Int]) = inputs.reduce((a,b)=> if(fun(b)>fun(a)) b else a)
def largestAt2(fun: (Int) => Int, inputs: Seq[Int]) = inputs.map(x => (x, fun(x))).reduceLeft((x,y) => if (x._2 > y._2) x else y)._1
println(largestAt1(x => 10 * x - x * x, 1 to 10))
println(largestAt2(x => 10 * x - x * x, 1 to 10))

def ajustToPair(fun: (Int, Int) => Int) = (x: (Int, Int)) => fun(x._1, x._2)
val x = ajustToPair(_ * _)((6, 7))
println(x)
val pairs = (1 to 10) zip (11 to 20)
println(pairs)
val y = pairs.map(ajustToPair(_ + _))
println(y)

val a = Array("asd","df","abcd")
val b = Array(3,2,4)
val c = Array(3,2,1)
println(a.corresponds(b)(_.length == _))
println(a.corresponds(c)(_.length == _))

def unless(condition: => Boolean)(block: => Unit) { if (!condition) { block } }
unless (0 > 1) { println("Unless!") }