相关疑难解决方法(0)

精度与 精确

我想知道的是在更新我的对象在游戏中的位置时是否应该使用System.currentTimeMillis()或System.nanoTime()？它们的运动变化与自上次呼叫后经过的时间成正比,我希望尽可能精确.

我读过不同的操作系统之间存在一些严重的时间分辨率问题(即Mac/Linux的分辨率几乎为1毫秒,而Windows的分辨率为50毫秒).我主要在Windows上运行我的应用程序,50ms分辨率似乎非常不准确.

有没有比我列出的两个更好的选择？

有什么建议/意见吗？

我遇到了这个老问题,并使用scala 2.10.3进行了以下实验.

我重写了Scala版本以使用显式尾递归:

import scala.annotation.tailrec

object ScalaMain {
  private val t = 20

  private def run() {
    var i = 10
    while(!isEvenlyDivisible(2, i, t))
      i += 2
    println(i)
  }

  @tailrec private def isEvenlyDivisible(i: Int, a: Int, b: Int): Boolean = {
    if (i > b) true
    else (a % i == 0) && isEvenlyDivisible(i+1, a, b)
  }

  def main(args: Array[String]) {
    val t1 = System.currentTimeMillis()
    var i = 0
    while (i < 20) {
      run()
      i += 1 …

我编写了一些 Scala 代码来对集合执行元素操作。在这里，我定义了两个执行相同任务的方法。一种方法使用zip，另一种使用zipped.

def ES (arr :Array[Double], arr1 :Array[Double]) :Array[Double] = arr.zip(arr1).map(x => x._1 + x._2)

def ES1(arr :Array[Double], arr1 :Array[Double]) :Array[Double] = (arr,arr1).zipped.map((x,y) => x + y)

为了在速度方面比较这两种方法，我编写了以下代码：

def fun (arr : Array[Double] , arr1 : Array[Double] , f :(Array[Double],Array[Double]) => Array[Double] , itr : Int) ={
  val t0 = System.nanoTime()
  for (i <- 1 to itr) {
       f(arr,arr1)
       }
  val t1 = System.nanoTime()
  println("Total Time Consumed:" + ((t1 - t0).toDouble / 1000000000).toDouble + "Seconds") …

我知道在Java虚拟机(JVM)中,可能需要进行预热,因为Java使用延迟加载过程加载类,因此您需要确保在启动主事务之前初始化对象.我是一名C++开发人员,不必处理类似的要求.

但是,我无法理解的部分如下:

1. 您应该预热哪些代码部分？
2. 即使我热身代码的某些部分,它仍然保持多长时间(假设这个术语只表示你的类对象保留在内存中多长时间)？
3. 如果每次收到活动时都有需要创建的对象,它会如何帮助？

考虑一个例子,期望通过套接字接收消息的应用程序,并且事务可以是新订单,修改订单和取消订单或确认的交易.

请注意,该应用程序是关于高频交易(HFT),因此性能非常重要.

如何myEval(f, args)在Scala中定义一个函数,它将另一个函数f和参数作为输入args,其输出是f(args)什么？

我不想myEval拥有关于arity或argument类型的任何先验知识f.

为什么这有用？这是解决实现泛型timeMyFunction(f, args)方法问题的一种方法.如果有办法通过某种懒惰的val构造来做到这一点,那也会很有趣.

编辑:在这个问题中解释了实现计时方法的更好方法.通过调用timeMyFunction( { f(args) } ),函数调用包含在匿名函数中Unit => Unit.所以timeMyFunction只需要采用0-arity函数.

编辑2:请参阅Dirk的回答,这可能是一种更有效的方法,可以f通过引用传递来避免匿名函数.

所以我对这个问题的理由现在纯粹是我的Scala教育.

我想为我的 Spark 程序执行速度计时，但由于懒惰，这非常困难。让我们在这里考虑一下这个（无意义的）代码：

var graph = GraphLoader.edgeListFile(context, args(0))
val graph_degs = graph.outerJoinVertices(graph.degrees).triplets.cache

/* I'd need to start the timer here */
val t1 = System.currentTimeMillis  
val edges = graph_degs.flatMap(trip =>  { /* do something*/ })
                      .union(graph_degs)

val count = edges.count
val t2 = System.currentTimeMillis 
/* I'd need to stop the timer here */

println("It took " + t2-t1 + " to count " + count)

问题是，转换是懒惰的，所以val count = edges.count在行之前没有任何评估。但是根据我的观点，t1尽管上面的代码没有值，但还是得到了一个值……t1尽管在代码中的位置，但在计时器启动后对上面的代码进行了评估。那是个问题...

在 Spark Web UI 中，我找不到任何有趣的东西，因为我需要在该特定代码行之后花费时间。您认为是否有一个简单的解决方案可以查看何时对一组转换进行真实评估？

什么是以下集合类型之间的差异斯卡拉：List和LazyList类型？