Scala：计算标准偏差的通用方法是什么

package ca.mikelavender

import scala.math.{Fractional,Integral,Numeric,_}

package object genericstats {

  def stdDev[T: Numeric](xs: Iterable[T]): Double = sqrt(variance(xs))

  def variance[T: Numeric](xs: Iterable[T]): Double = implicitly[Numeric[T]] match {
    case num: Fractional[_] => {
      val avg = mean(xs)
      num.toDouble(
        xs.foldLeft(num.zero)((b,a) =>
          num.plus(b,num.times(num.minus(a,avg),num.minus(a,avg))))) /
        xs.size
    }
    case num: Integral[_] => {
      val avg = mean(xs)
      num.toDouble(
        xs.foldLeft(num.zero)((b,avg))))) /
        xs.size
    }
  }

  /**
    * https://stackoverflow.com/questions/6188990/writing-a-generic-mean-function-in-scala
    */
  def mean[T: Numeric](xs: Iterable[T]): T = implicitly[Numeric[T]] match {
    case num: Fractional[_] => import num._; xs.sum / fromInt(xs.size)
    case num: Integral[_] => import num._; xs.sum / fromInt(xs.size)
    case _ => sys.error("Undivisable numeric!")
  }

}

像Numeric这样的类型类的目标是为类型提供一组操作,以便您可以编写在具有类型类实例的任何类型上一般工作的代码. Numeric提供了一组操作,其子类Integral和Fractional另外提供了更具体的操作(但它们也表征了更少的类型).如果您不需要这些更具体的操作,您可以简单地在Numeric级别工作,但不幸的是在这种情况下您可以.

让我们从卑鄙开始吧.这里的问题是除法对于整数和分数类型意味着不同的东西,并且根本不提供仅为数字的类型. Daniel的answer you’ve linked通过调度Numeric实例的运行时类型来解决这个问题,如果实例不是Fractional或Integral,则只会崩溃(在运行时).

我将不同意丹尼尔(或者至少是五年前的丹尼尔),并说这不是一个很好的方法 – 它既是真正的差异,也是同时抛出很多类型的安全.我认为有三种更好的解决方案.

仅为小数类型提供这些操作

您可能会认为取整数类型对整数类型没有意义,因为积分除失了结果的小数部分,并且仅为小数类型提供：

def mean[T: Fractional](xs: Iterable[T]): T = {
  val T = implicitly[Fractional[T]]

  T.div(xs.sum,T.fromInt(xs.size))
}

或者使用漂亮的隐式语法：

def mean[T: Fractional](xs: Iterable[T]): T = {
  val T = implicitly[Fractional[T]]
  import T._

  xs.sum / T.fromInt(xs.size)
}

最后一个句法要点：如果我发现我必须隐式编写[SomeTypeClass [A]]以获取对类型类实例的引用,我倾向于去除上下文绑定([A：SomeTypeClass]部分)以清理事物位：

def mean[T](xs: Iterable[T])(implicit T: Fractional[T]): T =
  T.div(xs.sum,T.fromInt(xs.size))

但这完全是品味问题.

返回具体的小数类型

你也可以使mean返回像Double这样的具体小数类型,并在执行操作之前简单地将Numeric值转换为该类型：

def mean[T](xs: Iterable[T])(implicit T: Numeric[T]): Double =
  T.toDouble(xs.sum) / xs.size

或者,等效但使用Numeric的toDouble语法：

import Numeric.Implicits._

def mean[T: Numeric](xs: Iterable[T]): Double = xs.sum.toDouble / xs.size

这为积分和分数类型(最高精度为Double)提供了正确的结果,但代价是使您的操作不那么通用.

创建一个新的类类

最后,您可以创建一个新类型类,为Fractional和Integral提供共享除法运算：

trait Divisible[T] {
  def div(x: T,y: T): T
}

object Divisible {
  implicit def divisibleFromIntegral[T](implicit T: Integral[T]): Divisible[T] =
    new Divisible[T] {
      def div(x: T,y: T): T = T.quot(x,y)
    }

  implicit def divisibleFromFractional[T](implicit T: Fractional[T]): Divisible[T] =
    new Divisible[T] {
      def div(x: T,y: T): T = T.div(x,y)
    }
}

然后：

def mean[T: Numeric: Divisible](xs: Iterable[T]): T =
  implicitly[Divisible[T]].div(xs.sum,implicitly[Numeric[T]].fromInt(xs.size))

这本质上是原始均值的更原则的版本 – 而不是在运行时调度子类型,您使用新类型表征子类型.有更多的代码,但没有运行时错误的可能性(除非当然xs是空的等等,但这是所有这些方法都遇到的正交问题).

结论

在这三种方法中,我可能会选择第二种,在您的情况下,由于您的方差和stdDev已经返回Double,因此在您的情况下看起来特别合适.在这种情况下,整个事情看起来像这样：

import Numeric.Implicits._

def mean[T: Numeric](xs: Iterable[T]): Double = xs.sum.toDouble / xs.size

def variance[T: Numeric](xs: Iterable[T]): Double = {
  val avg = mean(xs)

  xs.map(_.toDouble).map(a => math.pow(a - avg,2)).sum / xs.size
}

def stdDev[T: Numeric](xs: Iterable[T]): Double = math.sqrt(variance(xs))

……你已经完成了.

在实际代码中,我可能会查看像Spire这样的库,而不是使用标准库的类型类.