Scala BigInt类代码示例

//设置package包名称以及导入依赖的类
// ??? ?? ???. 40C20 ?? ?? ??. ??? ????? ??? ????? ??.

import scala.math.BigInt
object Problem015 {
  def main(args: Array[String]) {

    def combination(n: Int, k: Int): BigInt = {
      require(n > 0 && k >= 0)

      if (n < k || n < 1 || k < 0)
        0
      else if (n == k || k == 0)
        1
      else {
        val kk = if (n - k < k) n - k else k
        val nList = ((n to (1, -1)).toList take kk).map(BigInt(_)) // ??
        val kList = (kk to (1, -1)).toList // ??
        val up = (BigInt(1) /: nList)(_ * _) // ???? ?? BigInt ? ??
        (up /: kList)(_ / _);
      }
    }

    val start = System.currentTimeMillis();
    val result = combination(40, 20);
    println("????", System.currentTimeMillis() - start, "??", result)
  }
} 

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

import java.util.Scanner

import com.example.util.BenchmarkHelper._

import scala.math.BigInt


object GCDEuclidian extends App{

  def calculateGCDfor(a: BigInt, b: BigInt): BigInt = {
    if (b == BigInt(0)) a
    else {
      if(a > b) calculateGCDfor(b, a - b * (a / b))
      else calculateGCDfor(a, b - a * (b / a))
    }
  }

  val  s = new Scanner(System.in)
  val a = s.nextBigInteger()
  val b = s.nextBigInteger()

  //Test for example for a = 74356764380* 13   &   b = 74356764380 * 5
  time {
    println{
      s"GCD for numbers $a and $b is: \t" + calculateGCDfor(a, b)
    }
  }
} 

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


    import java.io.File
    import scala.math.BigInt

    import de.zalando.play.controllers.PlayPathBindables


//noinspection ScalaStyle
package yaml {


    case class MultipartPostResponses200(name: BothPostResponses200Name, year: BothPostYear, fileSize: BothPostYear, fileName: BothPostResponses200Name) 
    case class BothPostResponses200(name: BothPostResponses200Name, year: BothPostYear, avatarSize: BothPostYear, ringtoneSize: BothPostYear) 


    import play.api.libs.json._
    import play.api.libs.functional.syntax._
    import de.zalando.play.controllers.MissingDefaultWrites
    object ResponseWrites extends MissingDefaultWrites {
    implicit val BothPostResponses200Writes: Writes[BothPostResponses200] = new Writes[BothPostResponses200] {
        def writes(ss: BothPostResponses200) =
          Json.obj(
            "name" -> ss.name, 
            "year" -> ss.year, 
            "avatarSize" -> ss.avatarSize, 
            "ringtoneSize" -> ss.ringtoneSize
          )
        }
    implicit val MultipartPostResponses200Writes: Writes[MultipartPostResponses200] = new Writes[MultipartPostResponses200] {
        def writes(ss: MultipartPostResponses200) =
          Json.obj(
            "name" -> ss.name, 
            "year" -> ss.year, 
            "fileSize" -> ss.fileSize, 
            "fileName" -> ss.fileName
          )
        }
    }
}

// should be defined after the package because of the https://issues.scala-lang.org/browse/SI-9922

//noinspection ScalaStyle
package object yaml {

    type MultipartPostAvatar = Option[File]
    type BothPostResponses200Name = Option[String]
    type BothPostYear = Option[BigInt]


import play.api.mvc.{QueryStringBindable, PathBindable}

    implicit val bindable_FileQuery = PlayPathBindables.queryBindableFile
    implicit val bindable_BigIntQuery = PlayPathBindables.queryBindableBigInt
    implicit val bindable_OptionFileQuery: QueryStringBindable[Option[File]] = PlayPathBindables.createOptionQueryBindable[File]
    implicit val bindable_OptionBigIntQuery: QueryStringBindable[Option[BigInt]] = PlayPathBindables.createOptionQueryBindable[BigInt]

} 

//设置package包名称以及导入依赖的类
package org.bitcoins.rpc.marshallers.networking

import org.bitcoins.rpc.bitcoincore.networking.{NetworkTotals, NetworkTotalsImpl}
import scala.math.BigInt
import spray.json._


object NetworkTotalsMarshaller extends DefaultJsonProtocol {
  val totalBytesRecvKey = "totalbytesrecv"
  val totalBytesSentKey = "totalbytessent"
  val timeInMilliSecondsKey = "timemillis"

  implicit object NetworkTotalFormatter extends RootJsonFormat[NetworkTotals] {
    override def read (value: JsValue) : NetworkTotals = {
      val obj = value.asJsObject
      val totalBytesRecv = obj.fields(totalBytesRecvKey).convertTo[Int]
      val totalBytesSent = obj.fields(totalBytesSentKey).convertTo[Int]
      val timeInMilliSeconds = obj.fields(timeInMilliSecondsKey).convertTo[BigInt]
      NetworkTotalsImpl(totalBytesRecv, totalBytesSent, timeInMilliSeconds)
    }

    override def write (NetworkDetail : NetworkTotals) : JsValue = {
      val m : Map[String, JsValue] = Map (
        totalBytesRecvKey -> JsNumber(NetworkDetail.totalBytesRecv),
        totalBytesSentKey -> JsNumber(NetworkDetail.totalBytesSent),
        timeInMilliSecondsKey -> JsNumber(NetworkDetail.timeInMilliSeconds)
      )
      JsObject(m)
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.bitcoins.rpc.marshallers.networking

import org.bitcoins.rpc.bitcoincore.networking.NetworkTotals
import org.scalatest.{FlatSpec, MustMatchers}
import spray.json._

import scala.math.BigInt


class NetworkTotalsMarshallerTest extends FlatSpec with MustMatchers {
  val str =
    """
      |{
      |    "totalbytesrecv" : 1972832211,
      |    "totalbytessent" : 71483458,
      |    "timemillis" : 1452264952971
      |}
    """.stripMargin

  val json = str.parseJson
  val NetworkDetail : NetworkTotals = NetworkTotalsMarshaller.NetworkTotalFormatter.read(json)

  "NetworkTotals" must "parse network total infos" in {
    NetworkDetail.totalBytesRecv must be (1972832211)
    NetworkDetail.totalBytesSent must be (71483458)
    NetworkDetail.timeInMilliSeconds must be (BigInt("1452264952971"))
  }

  it must "write network total info" in {
    val writtenNetworkTotal = NetworkTotalsMarshaller.NetworkTotalFormatter.write(NetworkDetail)
    writtenNetworkTotal.asJsObject.fields("totalbytesrecv") must be (JsNumber(1972832211))
    writtenNetworkTotal.asJsObject.fields("totalbytessent") must be (JsNumber(71483458))
    writtenNetworkTotal.asJsObject.fields("timemillis") must be (JsNumber(BigInt("1452264952971")))

  }
}