调用函数库scala

Question

我希望从ta-lib的scala包装器中调用ATR函数。但是我不知道如何正确使用包装器。

package io.github.patceev.talib

import com.tictactec.ta.lib.{Core, MInteger, RetCode}

import scala.concurrent.Future

object Volatility {
    def ATR(
        highs: Vector[Double],
        lows: Vector[Double],
        closes: Vector[Double],
        period: Int = 14
    )(implicit core: Core): Future[Vector[Double]] = {
        val arrSize = highs.length - period + 1

        if (arrSize < 0) {
            Future.successful(Vector.empty[Double])
        } else {
            val begin = new MInteger()
            val length = new MInteger()
            val result = Array.ofDim[Double](arrSize)

            core.atr(
                0, highs.length - 1, highs.toArray, lows.toArray, closes.toArray,
                period, begin, length, result
            ) match {
                case RetCode.Success =>
                    Future.successful(result.toVector)
                case error =>
                    Future.failed(new Exception(error.toString))
            }
        }
    }
}

有没有人可以解释一下如何使用函数并将结果打印到控制台。

在此之前，非常感谢您。

Answer 1

关于语法，Scala是许多语言中的一种，在这些语言中，您可以调用函数和方法，并在括号中传递参数(大多数情况下，但现在让我们保持简单)：

def myFunction(a: Int): Int = a + 1

myFunction(1) // myFunction is called and returns 2

最重要的是，Scala允许指定多个参数列表，如以下示例所示：

def myCurriedFunction(a: Int)(b: Int): Int = a + b

myCurriedFunction(2)(3) // myCurriedFunction returns 5

您也可以部分应用myCurriedFunction，但同样，让我们暂时保持简单。其主要思想是您可以将多个参数列表传递给一个函数。

在此基础上，Scala允许定义一个隐式参数列表，编译器将根据一些作用域规则自动检索这些参数。例如，Future使用隐式参数：

// this defines how and where callbacks are run
// the compiler will automatically "inject" them for you where needed
implicit val ec: ExecutionContext = concurrent.ExecutionContext.global

Future(4).map(_ + 1) // this will eventually result in a Future(5)

请注意，Future和map都有第二个参数列表，允许指定隐式执行上下文。通过在作用域中使用它，编译器将在调用点为您“注入”它，而不必显式编写它。你仍然可以这样做，结果会是

Future(4)(ec).map(_ + 1)(ec)

也就是说，我不知道您正在使用的库的细节，但其思想是您必须实例化一个Core类型的值，并将其绑定到implicit val或显式传递它。

生成的代码如下所示

val highs: Vector[Double] = ???
val lows: Vector[Double] = ???
val closes: Vector[Double] = ???
implicit val core: Core = ??? // instantiate core
val resultsFuture = Volatility.ATR(highs, lows, closes) // core is passed implicitly
for (results <- resultsFuture; result <- results) {
  println(result)
}

请注意，根据您的情况，您可能还必须使用隐式ExecutionContext来运行此代码(因为您是从Future中提取Vector[Double] )。选择正确的执行上下文是另一种问题，但为了解决这个问题，您可能希望使用全局执行上下文。

额外的

关于我留下的一些观点，这里有一些建议，希望能被证明是有用的：

• Operators
• Multiple Parameter Lists (Currying)
• Implicit Parameters
• Scala Futures