//设置package包名称以及导入依赖的类
package chapter17


  import scala.collection.immutable.TreeSet
  val ts = TreeSet(9, 3, 1, 8, 0, 2, 7, 4, 6, 5)
  println(ts)
  val ts2 = TreeSet(ts.toSeq: _*)(ts.ordering.reverse)
  println(ts2)
  val cs = TreeSet('f', 'u', 'n')
  println(cs)

  import scala.collection.immutable.TreeMap
  var tm = TreeMap(3 -> 'x', 1 -> 'x', 4 -> 'x')
  tm += (2 -> 'x')
  println(tm)

  val tm2 = TreeMap(tm.toSeq: _*)(tm.ordering.reverse)
  println(tm2)

} 

//设置package包名称以及导入依赖的类
package akka.performance.workbench

import scala.collection.immutable.TreeMap

@SerialVersionUID(1L)
case class Stats(
  name: String,
  load: Int,
  timestamp: Long = System.currentTimeMillis,
  durationNanos: Long = 0L,
  n: Long = 0L,
  min: Long = 0L,
  max: Long = 0L,
  mean: Double = 0.0,
  tps: Double = 0.0,
  percentiles: TreeMap[Int, Long] = Stats.emptyPercentiles) {

  def median: Long = percentiles(50)
}

object Stats {
  val emptyPercentiles = TreeMap[Int, Long](
    5 -> 0L,
    25 -> 0L,
    50 -> 0L,
    75 -> 0L,
    95 -> 0L)
} 

//设置package包名称以及导入依赖的类
package akka.contrib.pattern.protobuf

import akka.actor.{ ExtendedActorSystem, Address }
import akka.testkit.AkkaSpec
import akka.contrib.pattern.DistributedPubSubMediator._
import akka.contrib.pattern.DistributedPubSubMediator.Internal._
import akka.actor.Props
import scala.collection.immutable.TreeMap

@org.junit.runner.RunWith(classOf[org.scalatest.junit.JUnitRunner])
class DistributedPubSubMessageSerializerSpec extends AkkaSpec {

  val serializer = new DistributedPubSubMessageSerializer(system.asInstanceOf[ExtendedActorSystem])

  def checkSerialization(obj: AnyRef): Unit = {
    val blob = serializer.toBinary(obj)
    val ref = serializer.fromBinary(blob, obj.getClass)
    ref should be(obj)
  }

  " DistributedPubSubMessages" must {

    "be serializable" in {
      val address1 = Address("akka.tcp", "system", "some.host.org", 4711)
      val address2 = Address("akka.tcp", "system", "other.host.org", 4711)
      val address3 = Address("akka.tcp", "system", "some.host.org", 4712)
      val u1 = system.actorOf(Props.empty, "u1")
      val u2 = system.actorOf(Props.empty, "u2")
      val u3 = system.actorOf(Props.empty, "u3")
      val u4 = system.actorOf(Props.empty, "u4")
      checkSerialization(Status(Map(address1 -> 3, address2 -> 17, address3 -> 5)))
      checkSerialization(Delta(List(
        Bucket(address1, 3, TreeMap("/user/u1" -> ValueHolder(2, Some(u1)), "/user/u2" -> ValueHolder(3, Some(u2)))),
        Bucket(address2, 17, TreeMap("/user/u3" -> ValueHolder(17, Some(u3)))),
        Bucket(address3, 5, TreeMap("/user/u4" -> ValueHolder(4, Some(u4)), "/user/u5" -> ValueHolder(5, None))))))
      checkSerialization(Send("/user/u3", "hello", localAffinity = true))
      checkSerialization(SendToAll("/user/u3", "hello", allButSelf = true))
      checkSerialization(Publish("mytopic", "hello"))
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.viajobien.busy.models.routing

import scala.collection.immutable.TreeMap


class RouteBuilder(routeTables: List[Route]) extends PathUtil {

  def createRouteTree: RouteTree = routeTables.foldLeft[RouteTree](
    new RouteEmpty()
  ) { (rn, rt) =>
      rn ++ this.buildTree(rt, this.splitPath(rt.path))
    }

  private def buildTree(routeTable: Route, parts: List[String] = Nil): RouteTree =
    parts match {
      case Nil                 => new RouteEndpointNode(List(routeTable))
      case PATH_WILDCARD :: ps => new RouteNode(TreeMap(PATH_WILDCARD -> new RouteWildcardNode(List(routeTable))))
      case p :: ps             => new RouteNode(TreeMap(p -> this.buildTree(routeTable, ps)))
    }

} 

//设置package包名称以及导入依赖的类
import scala.collection.immutable.TreeMap

package object PaidDatas {
  type PaidDatas = TreeMap[String, LandRegistryPricePaidDataItem]
}


class LandRegistryPricePaidData(val paidDatas: PaidDatas.PaidDatas ) {

  def this(ppds: List[LandRegistryPricePaidDataItem] = List() ) {
    this(ppds.map(t => t.transactionUniqueIdentifier -> t)(collection.breakOut) : PaidDatas.PaidDatas)
  } 

  
  def merge(ppds: List[LandRegistryPricePaidDataItem]): LandRegistryPricePaidData = { 
    val newListOfPpds = ppds.foldLeft(paidDatas)((z, t) => 
      t.recordStatus match {
        case "D" => z - t.transactionUniqueIdentifier
        case _   => z + (t.transactionUniqueIdentifier -> t)
      }
    ) 
     
    new LandRegistryPricePaidData(newListOfPpds)
  }
} 

//设置package包名称以及导入依赖的类
package com.rklaehn.persistentsummary

import ichi.bench.Thyme
import scala.collection.immutable.TreeMap

object TreeSetStdDevBench extends App {

  val cachedSummary = PersistentSummary.treeMapValue(StdDevSummary)

  def avgAndStdDev(values: TreeMap[Int, Double]): (Long, Double, Double) = {
    val (n, sum, sum2) = cachedSummary(values)
    val avg = sum / n
    val variance = sum2 / (n - 1) - (sum * sum) / (n * (n - 1.0))
    val stdDev = math.sqrt(variance)
    (n, avg, stdDev)
  }

  def avgAndStdDevUncached(values: TreeMap[Int, Double]): (Long, Double, Double) = {
    val (n, sum, sum2) = values.values.foldLeft(StdDevSummary.empty) { case (a, e) => StdDevSummary.combine(a, StdDevSummary.apply(e)) }
    val avg = sum / n
    val variance = sum2 / (n - 1) - (sum * sum) / (n * (n - 1.0))
    val stdDev = math.sqrt(variance)
    (n, avg, stdDev)
  }

  val max = 16 * 1024

  val elements: TreeMap[Int, Double] = TreeMap((0 until max).map { i => i -> (i % 16).toDouble }: _*)

  println(avgAndStdDev(elements))

  val elements1 = elements + (max / 2 -> 1000.0)

  println(avgAndStdDev(elements1))

  val th = Thyme.warmed(warmth = Thyme.HowWarm.BenchOff, verbose = println)

  def stdDevUncached(): Double = {
    val elements1 = elements + (max / 2 -> 1000.0)
    avgAndStdDevUncached(elements1)._3
  }

  def stdDevCached(): Double = {
    val elements1 = elements + (max / 2 -> 1000.0)
    avgAndStdDev(elements1)._3
  }

  th.pbenchOffWarm(s"average and stddev when modifying one element in a collection of size $max")(th.Warm(stdDevCached()))(th.Warm(stdDevUncached()))
} 

//设置package包名称以及导入依赖的类
package com.wavesplatform.generator

import scala.collection.immutable.TreeMap

class DistributedRandomGenerator[T](probabilities: Map[T, Float]) {
  assert(probabilities.values.sum == 1)
  def getRandom: T = {
    val rand = Math.random
    val g = probabilities.foldLeft((TreeMap[Float, Option[T]](0f -> None), 0f)) { case ((m, max), (t, prob)) =>
      val limit = max + prob
      (m.updated(limit, Some(t)), limit)
    }._1
    g.toSeq.sliding(2).find {
      case Seq((from, _), (to, _)) =>
        rand >= from && rand <= to
    }.flatMap(_.last._2).get
  }
} 

//设置package包名称以及导入依赖的类
package pl.touk.nussknacker.engine.api.util

import scala.collection.immutable.TreeMap

object MultiMap {
  def apply[K:Ordering, V] : MultiMap[K, V] = MultiMap(TreeMap())
}

case class MultiMap[K, V](map: TreeMap[K, List[V]]) {

  def add(key: K, value: V) : MultiMap[K, V] = {
    val newElement = map.get(key) match {
      case Some(list) => value::list
      case None => List(value)
    }
    MultiMap(map + (key -> newElement))
  }

  def remove(key: K, value: V) : MultiMap[K, V] = {
    map.get(key) match {
      case Some(list) =>
        //TODO: this is only ineffective operation, but in our case lists should be rather short
        val withRemovedEl = list.filterNot(_ == value)
        MultiMap(map + (key -> withRemovedEl))
      case None =>
        this
    }

  }

  def from(minimalKey: K) = MultiMap(map.from(minimalKey))

  def until(minimalKey: K) = MultiMap(map.until(minimalKey))


} 

//设置package包名称以及导入依赖的类
package com.swara.learn.genetic
package selectors

import scala.collection.immutable.TreeMap
import scala.util.Random


class RouletteWheelSelector[T] extends Selector[T] {

  override def select(individuals: Seq[Individual[T]], n: Int): Seq[Individual[T]] = {
    // Build a prefix-sum of individual fitness and store in a tree map. This allows us to perform
    // fitness-proportionate random selection in O(|I| log |I| + n log |I|).
    var wheel = TreeMap.empty[Double, Individual[T]]
    var total = 0.0

    individuals.foreach { i =>
      if (total == 0.0 || i.fitness > 0.0) {
        total += i.fitness
        wheel += total -> i
      }
    }

    // Randomly sample from the roulette wheel to choose the selected individuals.
    Seq.fill(n)(wheel.valuesIteratorFrom(Random.nextDouble() * total).next())
  }

} 

//设置package包名称以及导入依赖的类
package jkugiya.awstools.signer.v4

import scala.collection.immutable.TreeMap
import scala.collection.mutable

private[v4] final case class CanonicalHeaders private (private val headers: TreeMap[String, Vector[String]]) {

  val names: String = {
    val sb =
      headers.keySet
        .foldLeft(mutable.StringBuilder.newBuilder)((acc, v) => acc.append(v.toLowerCase()).append(';'))
    sb.deleteCharAt(sb.lastIndexOf(";"))
    sb.mkString
  }
  val mkString: String = {
    val sb = mutable.StringBuilder.newBuilder
    for {
      (key, values) <- headers
      value <- values
    } yield {
      sb.append(key.toLowerCase())
        .append(':')
        .append(value)
        .append('\n')
    }
    sb.toString()
  }

  def apply(key: String): Vector[String] = headers(key)

  def get(key: String): Option[Vector[String]] = headers.get(key)

}

object CanonicalHeaders {

  def apply(headers: Header*): CanonicalHeaders = {
    // HTTP header keys are case insensitive
    implicit val orderingForKey = new Ordering[String] {
      override def compare(x: String, y: String): Int =
        x.toLowerCase().compareTo(y.toLowerCase())
    }
    val internalMap =
      headers.foldLeft(TreeMap.empty[String, Vector[String]]) {
        case (acc, Header(k, v)) =>
          acc.get(k).fold {
            acc + (k -> Vector(v))
          } { values =>
            acc + (k -> (values :+ v))
          }
      }
    CanonicalHeaders(internalMap)
  }

} 

//设置package包名称以及导入依赖的类
package com.harry0000.kancolle

import scala.collection.{Map, Seq, mutable}
import scala.collection.immutable.TreeMap

package object ac {
  type ShipName = String
  type ShipMap = TreeMap[ShipCategory, Seq[ShipName]]
  object ShipMap {
    def empty: ShipMap = TreeMap.empty[ShipCategory, Seq[ShipName]]
    def apply(value: (ShipCategory, Seq[ShipName]) *): ShipMap = TreeMap(value: _*)
  }

  sealed abstract class ShipCategory(val name: String)
  object ShipCategory {
    case object Destroyer       extends ShipCategory("???")
    case object LightCruiser    extends ShipCategory("??")
    case object HeavyCruiser    extends ShipCategory("??")
    case object SeaplaneTender  extends ShipCategory("?????")
    case object AircraftCarrier extends ShipCategory("??")
    case object Submarine       extends ShipCategory("???")
    case object Battleship      extends ShipCategory("??")

    private val order: Map[ShipCategory, Int] = mutable.LinkedHashMap.empty ++ Seq(
      Destroyer,
      LightCruiser,
      HeavyCruiser,
      SeaplaneTender,
      AircraftCarrier,
      Submarine,
      Battleship
    ).zipWithIndex

    implicit val ordering: Ordering[ShipCategory] = Ordering.by(order.getOrElse(_, Int.MaxValue))

    def apply(shipType: String): ShipCategory = shipType match {
      case "??" => Destroyer
      case "??" => LightCruiser
      case "??" => HeavyCruiser
      case "??" => SeaplaneTender
      case "??" => AircraftCarrier
      case "??" => AircraftCarrier
      case "??" => Submarine
      case "??" => Battleship
    }

    def get(index: Int): Option[ShipCategory] = order.find(_._2 == index).map(_._1)

    def values: Seq[ShipCategory] = order.keys.toSeq
  }
} 

//设置package包名称以及导入依赖的类
import scala.collection.immutable.TreeMap
import scala.collection.mutable


object Set_Map {
  def main(args: Array[String]) {
    val data = mutable.Set.empty[String]
    data ++= List("1", "2", "2")
    data += "4"
    data --= List("2", "3")

    println(data)
    data += "1"
    println(data)
    data.clear
    println(data)

    val map = mutable.Map.empty[String, String]
    map("java") = "Hadoop"
    map("scala") = "Spark"
    println(map)
    println(map("java"))

    val treeSet = mutable.TreeSet(3, 45, 6, 3, 67, 35, 86, 32, 23)
    println(treeSet)
    val treeSetForChar = mutable.TreeSet("Spark", "Scala", "Hadoop")
    println(treeSetForChar)


    val treeMap = TreeMap("scala" -> "Spark", "Java" -> "Hadoop")
    val treeMap2=treeMap.addString(new StringBuilder("hello") ,"life is good","dsada","dasda")
    println(treeMap)
    println(treeMap2)




  }
} 

//设置package包名称以及导入依赖的类
package com.scalafi.dynamics.attribute

import com.scalafi.openbook.orderbook.OrderBook
import org.scalatest.FlatSpec

import scala.collection.immutable.TreeMap

class LabelSpec extends FlatSpec {

  // Mean price = (100 + 110) / 2 = 105
  val lowerMeanPriceOrderBook = new OrderBook("AAPL", TreeMap(100 -> 1), TreeMap(110 ->1))

  // Mean price = (110 + 120) / 2 = 115
  val higherMeanPriceOrderBook = new OrderBook("AAPL", TreeMap(110 -> 1), TreeMap(120 -> 1))

  "MeanPriceMovementLabel" should "correctly assign label" in {
    assert(MeanPriceMovementLabel(lowerMeanPriceOrderBook, higherMeanPriceOrderBook) == Some(MeanPriceMove.Up))
    assert(MeanPriceMovementLabel(higherMeanPriceOrderBook, lowerMeanPriceOrderBook) == Some(MeanPriceMove.Down))
    assert(MeanPriceMovementLabel(lowerMeanPriceOrderBook, lowerMeanPriceOrderBook) == Some(MeanPriceMove.Stationary))
  }
}