使用Scala实现一个基于性质的测试库

scala实现二分查找(非递归版) 前言:递归确实比较容易理解也比较容易实现,但是效率是真的不敢恭维的,所以,下面的scala实现二分查找是非递归方式!代码也比较容易理解,所以就没有什么注释啦,请见谅哈~ object BinarySearch { def main(args: Array[String]) { //test val arr = Array(1,2,3,4,5,6,7,8,9) pri... 阅读详情

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧……



package testing

import laziness.Stream
import state._
import parallelism._
import parallelism.Par.Par
import Gen._
import Prop._
import java.util.concurrent.{ExecutorService, Executors}

import state.RNG.Simple

import language.postfixOps
import language.implicitConversions

case class Prop(run: (MaxSize,TestCases,RNG) => Result) {
  def &&(p: Prop) = Prop {
    (max,n,rng) => run(max,n,rng) match {
      case Passed | Proved => p.run(max, n, rng)
      case x => x
    }
  }

  def ||(p: Prop) = Prop {
    (max,n,rng) => run(max,n,rng) match {
      // In case of failure, run the other prop.
      case Falsified(msg, _) => p.tag(msg).run(max,n,rng)
      case x => x
    }
  }

  /* This is rather simplistic - in the event of failure, we simply prepend
   * the given message on a newline in front of the existing message.
   */
  def tag(msg: String) = Prop {
    (max,n,rng) => run(max,n,rng) match {
      case Falsified(e, c) => Falsified(msg + "\n" + e, c)
      case x => x
    }
  }
}

object Prop {
  type SuccessCount = Int
  type TestCases = Int
  type MaxSize = Int
  type FailedCase = String

  sealed trait Result {
    def isFalsified: Boolean
  }
  case object Passed extends Result {
    def isFalsified = false
  }
  case class Falsified(failure: FailedCase,
                       successes: SuccessCount) extends Result {
    def isFalsified = true
  }
  case object Proved extends Result {
    def isFalsified = false
  }


  /* Produce an infinite random stream from a `Gen` and a starting `RNG`. */
  def randomStream[A](g: Gen[A])(rng: RNG): Stream[A] =
    Stream.unfold(rng)(rng => Some(g.sample.run(rng)))

  def forAll[A](as: Gen[A])(f: A => Boolean): Prop = Prop {
    (n,rng) => randomStream(as)(rng).zip(Stream.from(0)).take(n).map {
      case (a, i) => try {
        if (f(a)) Passed else Falsified(a.toString, i)
      } catch { case e: Exception => Falsified(buildMsg(a, e), i) }
    }.find(_.isFalsified).getOrElse(Passed)
  }


  // String interpolation syntax. A string starting with `s"` can refer to
  // a Scala value `v` as `$v` or `${v}` in the string.
  // This will be expanded to `v.toString` by the Scala compiler.
  def buildMsg[A](s: A, e: Exception): String =
    s"test case: $s\n" +
      s"generated an exception: ${e.getMessage}\n" +
      s"stack trace:\n ${e.getStackTrace.mkString("\n")}"

  def apply(f: (TestCases,RNG) => Result): Prop =
    Prop { (_,n,rng) => f(n,rng) }

  def forAll[A](g: SGen[A])(f: A => Boolean): Prop =
    forAll(g(_))(f)

  def forAll[A](g: Int => Gen[A])(f: A => Boolean): Prop = Prop {
    (max,n,rng) =>
      val casesPerSize = (n - 1) / max + 1
      val props: Stream[Prop] =
        Stream.from(0).take((n min max) + 1).map(i => forAll(g(i))(f))
      val prop: Prop =
        props.map(p => Prop { (max, n, rng) =>
          p.run(max, casesPerSize, rng)
        }).toList.reduce(_ && _)
      prop.run(max,n,rng)
  }

  def run(p: Prop,
          maxSize: Int = 100,
          testCases: Int = 100,
          rng: RNG = RNG.Simple(System.currentTimeMillis)): Unit =
    p.run(maxSize, testCases, rng) match {
      case Falsified(msg, n) =>
        println(s"! Falsified after $n passed tests:\n $msg")
      case Passed =>
        println(s"+ OK, passed $testCases tests.")
      case Proved =>
        println(s"+ OK, proved property.")
    }

  val ES: ExecutorService = Executors.newCachedThreadPool
  val p1 = Prop.forAll(Gen.unit(Par.unit(1)))(i =>
    Par.map(i)(_ + 1)(ES).get == Par.unit(2)(ES).get)

  def check(p: => Boolean): Prop = Prop { (_, _, _) =>
    if (p) Passed else Falsified("()", 0)
  }

  val p2 = check {
    val p = Par.map(Par.unit(1))(_ + 1)
    val p2 = Par.unit(2)
    p(ES).get == p2(ES).get
  }

  def equal[A](p: Par[A], p2: Par[A]): Par[Boolean] =
    Par.map2(p,p2)(_ == _)

  val p3 = check {
    equal (
      Par.map(Par.unit(1))(_ + 1),
      Par.unit(2)
    ) (ES) get
  }

  val S = weighted(
    choose(1,4).map(Executors.newFixedThreadPool) -> .75,
    unit(Executors.newCachedThreadPool) -> .25) // `a -> b` is syntax sugar for `(a,b)`

  def forAllPar[A](g: Gen[A])(f: A => Par[Boolean]): Prop =
    forAll(S.map2(g)((_,_))) { case (s,a) => f(a)(s).get }

  def checkPar(p: Par[Boolean]): Prop =
    forAllPar(Gen.unit(()))(_ => p)

  def forAllPar2[A](g: Gen[A])(f: A => Par[Boolean]): Prop =
    forAll(S ** g) { case (s,a) => f(a)(s).get }

  def forAllPar3[A](g: Gen[A])(f: A => Par[Boolean]): Prop =
    forAll(S ** g) { case s ** a => f(a)(s).get }

  val pint = Gen.choose(0,10) map (Par.unit(_))
  val p4 =
    forAllPar(pint)(n => equal(Par.map(n)(y => y), n))

  val forkProp = Prop.forAllPar(pint2)(i => equal(Par.fork(i), i)) tag "fork"
}

case class Gen[+A](sample: State[RNG,A]) {
  def map[B](f: A => B): Gen[B] =
    Gen(sample.map(f))

  def map2[B,C](g: Gen[B])(f: (A,B) => C): Gen[C] =
    Gen(sample.map2(g.sample)(f))

  def flatMap[B](f: A => Gen[B]): Gen[B] =
    Gen(sample.flatMap(a => f(a).sample))

  /* A method alias for the function we wrote earlier. */
  def listOfN(size: Int): Gen[List[A]] =
    Gen.listOfN(size, this)

  /* A version of `listOfN` that generates the size to use dynamically. */
  def listOfN(size: Gen[Int]): Gen[List[A]] =
    size flatMap (n => this.listOfN(n))

  def listOf: SGen[List[A]] = Gen.listOf(this)
  def listOf1: SGen[List[A]] = Gen.listOf1(this)

  def unsized = SGen(_ => this)

  def **[B](g: Gen[B]): Gen[(A,B)] =
    (this map2 g)((_,_))
}

object Gen {
  def unit[A](a: => A): Gen[A] =
    Gen(State.unit(a))

  val boolean: Gen[Boolean] =
    Gen(State(RNG.boolean))

  def choose(start: Int, stopExclusive: Int): Gen[Int] =
    Gen(State(RNG.nonNegativeInt).map(n => start + n % (stopExclusive-start)))

  def listOfN[A](n: Int, g: Gen[A]): Gen[List[A]] =
    Gen(State.sequence(List.fill(n)(g.sample)))

  val uniform: Gen[Double] = Gen(State(RNG.double))

  def choose(i: Double, j: Double): Gen[Double] =
    Gen(State(RNG.double).map(d => i + d*(j-i)))

  /* Basic idea is to add 1 to the result of `choose` if it is of the wrong
   * parity, but we require some special handling to deal with the maximum
   * integer in the range.
   */
  def even(start: Int, stopExclusive: Int): Gen[Int] =
    choose(start, if (stopExclusive%2 == 0) stopExclusive - 1 else stopExclusive).
    map (n => if (n%2 != 0) n+1 else n)

  def odd(start: Int, stopExclusive: Int): Gen[Int] =
    choose(start, if (stopExclusive%2 != 0) stopExclusive - 1 else stopExclusive).
    map (n => if (n%2 == 0) n+1 else n)

  def sameParity(from: Int, to: Int): Gen[(Int,Int)] = for {
    i <- choose(from,to)
    j <- if (i%2 == 0) even(from,to) else odd(from,to)
  } yield (i,j)

  def listOfN_1[A](n: Int, g: Gen[A]): Gen[List[A]] =
    List.fill(n)(g).foldRight(unit(List[A]()))((a,b) => a.map2(b)(_ :: _))

  def union[A](g1: Gen[A], g2: Gen[A]): Gen[A] =
    boolean.flatMap(b => if (b) g1 else g2)

  def weighted[A](g1: (Gen[A],Double), g2: (Gen[A],Double)): Gen[A] = {
    /* The probability we should pull from `g1`. */
    val g1Threshold = g1._2.abs / (g1._2.abs + g2._2.abs)

    Gen(State(RNG.double).flatMap(d => if (d < g1Threshold) g1._1.sample else g2._1.sample))
  }

  def listOf[A](g: Gen[A]): SGen[List[A]] =
    SGen(n => g.listOfN(n))

  /* Not the most efficient implementation, but it's simple.
   * This generates ASCII strings.
   */
  def stringN(n: Int): Gen[String] =
    listOfN(n, choose(0,127)).map(_.map(_.toChar).mkString)

  val string: SGen[String] = SGen(stringN)

  implicit def unsized[A](g: Gen[A]): SGen[A] = SGen(_ => g)

  val smallInt = Gen.choose(-10,10)
  val maxProp = forAll(listOf(smallInt)) { l =>
    val max = l.max
    !l.exists(_ > max) // No value greater than `max` should exist in `l`
  }

  def listOf1[A](g: Gen[A]): SGen[List[A]] =
    SGen(n => g.listOfN(n max 1))

  val maxProp1 = forAll(listOf1(smallInt)) { l =>
    val max = l.max
    !l.exists(_ > max) // No value greater than `max` should exist in `l`
  }

  // We specify that every sorted list is either empty, has one element,
  // or has no two consecutive elements `(a,b)` such that `a` is greater than `b`.
  val sortedProp = forAll(listOf(smallInt)) { l =>
    val ls = l.sorted
    l.isEmpty || ls.tail.isEmpty || !ls.zip(ls.tail).exists { case (a,b) => a > b }
  }

  object ** {
    def unapply[A,B](p: (A,B)) = Some(p)
  }

  /* A `Gen[Par[Int]]` generated from a list summation that spawns a new parallel
   * computation for each element of the input list summed to produce the final
   * result. This is not the most compelling example, but it provides at least some
   * variation in structure to use for testing.
   *
   * Note that this has to be a `lazy val` because of the way Scala initializes objects.
   * It depends on the `Prop` companion object being created, which references `pint2`.
   */
  lazy val pint2: Gen[Par[Int]] = choose(-100,100).listOfN(choose(0,20)).map(l =>
    l.foldLeft(Par.unit(0))((p,i) =>
      Par.fork { Par.map2(p, Par.unit(i))(_ + _) }))

  def genStringIntFn(g: Gen[Int]): Gen[String => Int] =
    g map (i => (s => i))
}

case class SGen[+A](g: Int => Gen[A]) {
  def apply(n: Int): Gen[A] = g(n)

  def map[B](f: A => B): SGen[B] =
    SGen { g(_) map f }

  def flatMap[B](f: A => SGen[B]): SGen[B] = {
    val g2: Int => Gen[B] = n => {
      g(n) flatMap { f(_).g(n) }
    }
    SGen(g2)
  }

  def **[B](s2: SGen[B]): SGen[(A,B)] =
    SGen(n => apply(n) ** s2(n))
}


object Examples {

  def main(args: Array[String]):Unit = {

    val rng = Simple(System.currentTimeMillis())

    val checkRes1 = Prop check { 100 - 100 + 100 == 100}
    println(checkRes1.run(1, 1, rng))

    val checkRes2 = Prop check { 100 - 100 + 100 == 0}
    println(checkRes2.run(1, 1, rng))

    val p2Res = Prop.p2.run(1, 1, rng)
    println(p2Res)

    val unitRes = Gen.unit(5).sample.run(rng)
    println(unitRes)

    val productGen = Gen.unit(3) ** Gen.unit(5)
    val productRes = productGen.sample.run(rng)
    println(productRes)

    //创建能够生成大小在闭区间[1, 100]的随机数的生成器
    val chooseGen = Gen.choose(1, 101)
    val size = 5
    //创建能够生成长度为5、元素大小在闭区间[1, 100]的链表的生成器
    val chooseGenListOfRes = Gen.listOf(chooseGen).g(size).sample.run(rng)
    println(chooseGenListOfRes)

    // 随机生成0 ~ 100 之间的数字
    val ge1le100Prop = Prop.forAll(chooseGen)((a: Int) =>  a >= 1 && a <= 100)
    // 0 ~ 100之间的数字的平方不可能全部都满足 <= 2500, 所以后续的测试有很大的概率不会通过
    val pow2le2500 = Prop.forAll(chooseGen)((a: Int) =>  math.pow(a, 2) <= 2500)
    val chooseProp = ge1le100Prop && pow2le2500 tag "检测生成的数字大小在[1, 100]之间出现失败案例 =>"
    val choosePropRes = Prop.run(chooseProp)

    val len = 100
    //check whether the String-Generator generates string which of the size is equql to len or not
    // 测试字符串生成器生成的字符串的长度是否与指定参数相等
    Prop.run(Prop.forAll(Gen.stringN(len)){(a: String) => a.length == len}, 10, 3, rng)
    //Prop.run(Prop.forAll(Gen.stringN(len)){(a: String) => a.length !=  len}, 10, 3, rng)

    val li = List(1, 3, 5, 7, 9)
    //assert List named li contains odd number only
    Prop.run(Prop.forAll(Gen.unit(li)){ li => li.exists(_ % 2 == 1)})

  }

}

上述代码的运行结果是:


Passed
Falsified((),0)
Passed
(5,Simple(1531276787839))
((3,5),Simple(1531276787839))
(List(30, 80, 26, 18, 18),Simple(236643744399618))
! Falsified after 0 passed tests:
 检测生成的数字大小在[1, 100]之间出现失败案例 =>
84
+ OK, passed 3 tests.
+ OK, passed 100 tests.

879675643@qq.com  lhever

.---.                                                                         
|   |   .              __.....__   .----.     .----.   __.....__              
|   | .'|          .-''         '.  \    \   /    /.-''         '.            
|   |<  |         /     .-''"'-.  `. '   '. /'   //     .-''"'-.  `. .-,.--.  
|   | | |        /     /________\   \|    |'    //     /________\   \|  .-. | 
|   | | | .'''-. |                  ||    ||    ||                  || |  | | 
|   | | |/.'''. \\    .-------------''.   `'   .'\    .-------------'| |  | | 
|   | |  /    | | \    '-.____...---. \        /  \    '-.____...---.| |  '-  
|   | | |     | |  `.             .'   \      /    `.             .' | |      
'---' | |     | |    `''-...... -'      '----'       `''-...... -'   | |      
      | '.    | '.                                                   |_|      
      '---'   '---'  
MTSC2025参会感悟:基于性质的 GUI 测试 传统的 GUI 功能测试技术在面对日益复杂的应用时逐渐力不从心,而基于性质的测试技术(Property-Based Testing, PBT) 作为下一代 GUI 自动化测试方法,正逐渐成为解决这一痛点的关键方案。本文将深入解析这一技术的原理、优势、实战应用及未来趋势,为测试工程师与开发者提供全面指南。 阅读详情

相关推荐

高斯-约当(Gauss-Jordan)消元法——c++代码实现

具体算法的详细原理请参照此篇博客:高斯-约当(Gauss-Jordan)消元法下面是具体c++代码,不保证程序最优化,提供一个可行的程序,供大家改进,同时感谢大家提意见。——大神勿喷呀,我是一个小菜鸟~void Guss_Jordan(int n,double *a)//阶数n 系数矩阵a { double*a_temp = new double[n*n * 2];//a与单位矩阵的组合

zwz的学习之路 6875

基于属性的测试,hypothesis以及查找bug

基于属性的测试 我慢慢滴慢慢滴学习到hypothesis是多么的聪明,但在一个非常基础的水平上,它允许你做的是,使用一个测试,以及测试参数的整个范围来取代测试一个单一的例子。 这里是一个简单的例子,基于我在2016年在Edinburgh的合作研讨会所给出的一个简单的演示。 你可以在这个链接vknight.org/Talks/2016-03-22-Division-by-11-and-prope...

qq_42370150的博客 993

深度学习Halcon中GPU显存利用率高,但GPU、CPU利用率较低,导致模型训练速度很慢,通过设置硬件参数的解决方法

深度学习Halcon中GPU显存利用率高,但GPU、CPU利用率较低,导致模型训练速度很慢,通过设置硬件参数的解决方法 前言 在训练自己模型的时候,会遇到GPU显存利用率高,但GPU、CPU利用率较低,导致模型训练速度很慢的问题。这个问题一方面是由于硬件没有设置到最佳工作状态,另一方面是代码中参数没有设置好。最近在跑Halcon DL遇到这个问题,而Halcon不像开源的几个框架那样自由,代码封装的比较多。所以遇到这种问题,只能在参数最优的情况下,通过设置硬件参数来提升性能。 当然,在跑DL之前,无论什么框

ZiLiangQin的博客 9919

使用Spock进行基于属性的测试

基于属性的测试是测试的替代方法,是对基于示例的测试的补充。 后者是我们一生都在做的事情:针对“示例”行使生产代码-我们认为这些输入具有代表性。 挑选这些示例本身就是一门艺术:“普通”输入,边缘情况,格式错误的输入等。但是为什么我们将自己限制为仅几个示例呢? 为什么不测试成千上万个… 所有输入? 这种方法至少有两个困难: 规模。 一个仅接受一个int输入的纯函数将需要40亿次测试。 这意...

321

maxwell 平面变压器仿真(一)

在学习开关电源设计的时候,我们难免要设计变压器,采用有限元仿真软件MAXWELL 可以帮助我们确定变压器的励磁电感,漏感等参数。对于我们的理论分析大有裨益。但是苦于这破软件的教程真的是相当的零散,我相信大家用起来也总是苦于没有系统的教程指导,撰写本文的目的有两个,一个是记录自己使用的一些问题,一个是给大家提供一个可以参考的文档。

qq_45405656的博客 8255

大模型学习笔记四:LangChain开发框架解析

1、模型I/O封装LLMs:大语言模型Chat Models:一般基于LLMs,但按对话结构重新封装PromptTemple:提示词模板OutputParser:解析输出2、数据连接封装Document Loaders:各种格式文件的加载器Document transformers:对文档的常用操作,如:split,filter,translate,extract metadata,etcTextr Embedding Models:文本向量化表示,用于检索等操作。

谢白羽 4285

Scala实现wordCount

废话不多说直接上代码 val list = List("rose is beautiful","jennie is beautiful","lisa is beautiful","jisoo is beautiful") /** * 第一步,将list中的元素按照分隔符这里是空格拆分,然后展开 * 先map(_.split(" "))将每一个元素按照空格拆分 ...

SX的博客 1万+

混合动作空间在强化学习中的创新应用:PDQN与MPDQN算法解析

本文深入解析了强化学习中处理混合动作空间的PDQN与MPDQN算法。针对既有离散选择又有连续调节的复杂决策场景,PDQN通过参数化深度Q网络,巧妙结合DQN与DDPG进行交替优化;MPDQN则进一步改进,为每个离散动作提供专属参数评估以减少干扰。文章通过游戏、自动驾驶等实例阐述了其应用价值与面临的挑战。

efc123456的博客 865

JAVA经典问题算法大全之scala版

/*【程序1】 题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析: 兔子的规律为数列1,1,2,3,5,8,13,21.... */ 方法1: object FirstRabit extends App{ var (f, f1, f2) = (1L, 1L, 1L)

chx3515的专栏 1891

通达信缠论中枢自动识别与画线实战指南

本文详细介绍了通达信缠论中枢自动识别与画线公式的实战应用。该工具通过严谨的算法逻辑,自动在K线图上标记出符合缠论定义的中枢区间,帮助投资者摆脱繁琐的手工画图,聚焦于价格与中枢的互动关系,从而高效识别趋势延续、背驰及第三类买卖点,提升缠论分析与交易决策的效率。

weixin_29267307的博客 664

sophgo sdk v23.03.01

C/C++程序建议在x86主机上使用交叉编译工具链编译生成可执行文件后,再拷贝到SoC目标平台运行。# 创建docker用户组,若已有docker组会报错,没关系可忽略。对于SoC模式,模型转换也需要在docker开发容器中完成;docker开发容器的配置参照前述章节相关内容。6、创建docker容器并进入Docker。# docker命令免root权限执行。# 将当前用户加入docker组。# 重启docker服务。# 安装 docker。3、安装docker。7、SoC 环境配置。

weixin_40723768的博客 916

为什么QuickCheck是Haskell开发者的必备工具:深度解析

在Haskell函数式编程的世界里,**QuickCheck**作为一款革命性的自动化测试工具,已经成为每个专业开发者的必备利器。这个强大的库通过随机测试和属性验证,彻底改变了Haskell程序测试的方式,让开发者能够以数学般的严谨性验证代码的正确性。无论你是Haskell新手还是经验丰富的开发者,掌握QuickCheck都将大幅提升你的代码质量和开发效率。 ## 🔍 QuickCheck的核

gitblog_00518的博客 470

富芮坤fr8008gp 240X280 lvgl项目启动

fr8008gp_240X280_lvgl项目启动

cheng___yi的博客 1758

Scala多线程实现

Actor 什么是Scala Actor (1)Scala中的Actor能够实现并行编程的强大功能,他是基于事件模板的并发机制。Scala是运用消息的发送接、收来实现多线程的。使用Scala能够更容易地实现多线程应用的开发。   多线程不是提高程序运行效率而是提高资源利用率   (2)并发(concurrency)和并行(parallellism)是: 解释一:并行是指两个或者多个事件...

qq_37001101的博客 4235

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

用Scala实现简单的Web和API服务器

【优快云 编者按】大家都知道Web和API服务器在互联网中的重要性,在计算机网络方面提供了最基本的界面。本文主要介绍了怎样利用Scala实现实时聊天网站和API服务器,通过本篇文章,你定将受益匪浅。 作者 | Haoyi 译者 |弯月,责编 | 刘静 出品 | 优快云(ID:优快云news) 以下为译文: Web和API服务器是互联网系统的骨干,它们为计算机通过网...

优快云资讯 3445

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

使用scala实现简单的rpc案例

题目:使用scala的actor构建一个简单的RPC调用实例模仿ResourceManager和NodeManager之间的交互,1、NodeManager向ResourceManager进行注册(传递的参数是:主机名、内存、CPU、端口)2、ResourceManager将接收到的消息进行消息匹配,如果是注册消息,将消息保存3、发送注册请求的response给NodeManager(传递host...

_a_0_ 695

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

快速排序:Scala实现

快速排序的是Scala版本: def quickSort[T <% Ordered[T]](list: List[T]): List[T] = list match { case Nil => Nil case x :: xs => val (before, after) = xs partition ( _ < x ) quickSort(before)

Freecloud 2544

DBSCAN算法学习笔记及scala实现

一、算法概述  DBSCAN(Density-Based Spatial Clustering of Applications with Noise,具有噪声的基于密度的聚类方法)是一种基于密度的空间聚类算法,相比其他的聚类方法,基于密度的聚类方法可以在有噪音的数据中发现各种形状和各种大小的簇。基于密度的聚类是寻找被低密度区域分离的高密度区域,这些高密度区域就是一个一个的簇,这里的密度指的是一个样本

Yage的博客 6346

用scala实现一个sql执行引擎-(上)

前言 在实时计算中,通常是从队列中收集原始数据,这种原始数据在内存中通常是一个java bean,把数据收集过来以后,通常会把数据落地到数据库,供后面的ETL使用。举个一个简单的例子,对一个游戏来说,为了统计某个游戏,某个服务器的登陆注册 等事件,原始数据对应的java bean可能会是这样: public class Event { private String user...

weixin_30639719的博客 188

Python 100例【python 3.6版本】【更新ing】

Python 100例实例1实例2实例3实例4实例5 实例1 题目:有四个数字:1、2、3、4,能组成多少个互不相同且无重复数字的三位数?各是多少? 程序分析: ①可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列 ②使用 itertools 中的 permutations 即可。相关内容可浏览 itertools 中的 permutations 实现全排列和任意排列 源码: 方法1 counter=0 for i in range(1,5): for j in

MasterMiao的博客 788

Kahan summation algorithm

In numerical analysis, theKahan summation algorithm (also known ascompensated summation) significantly reduces thenumerical error in the total obtained by adding asequence of finiteprecisionfloating

一路向前 3323

Scala容器库(Scala’s Collections Library)

简介(Introduction) Martin Odersky和Lex Spoon 在许多人看来,新的集合框架是Scala 2.8中最显著的改进。此前Scala也有集合(实际上新框架大部分地兼容了旧框架),但2.8中的集合类在通用性、一致性和功能的丰富性上更胜一筹。 即使粗看上去集合新增的内容比较微妙,但这些改动却足以对开发者的编程风格造成深远的影响。实际上,就好像你从事一个高层

wk022的专栏 2054

同时使用java和scala语言的maven项目pom文件示例

主要就是在pom.xml中添加scala的三个依赖包和maven-scala插件,配置如下:&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in...

lhever_的博客 3157

使用Scala实现链表(List)数据结构

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧。package fpinscala.datastructures sealed trait List[+A] case object Nil...

lhever_的博客 1877

Monoid在Scala中的应用笔记

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,而是...

lhever_的博客 1404

Monad在Scala中的应用笔记

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,而是...

lhever_的博客 1310
上一篇: 使用Scala实现一个并发库(NonBlocking版本)
下一篇: 使用Scala从头实现一个简单的语法分析器组合字库
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值