Scala：通用加权平均函数

Question

我想实现一个通用的加权平均函数，它放宽了对值和权重为同一类型的要求。即，我想支持说：(value:Float,weight:Int) 和(value:Int,weight:Float) 参数的序列，而不仅仅是：(value:Int,weight:Int)。 [在此之前，请参阅我之前的 question。]

这是我目前拥有的：

def weightedSum[A: Numeric](weightedValues: GenSeq[(A, A)]): (A, A)

def weightedAverage[A: Numeric](weightedValues: GenSeq[(A, A)]): A = {
    val (weightSum, weightedValueSum) = weightedSum(weightedValues)
    implicitly[Numeric[A]] match {
        case num: Fractional[A] => ...
        case num: Integral[A] => ...
        case _ => sys.error("Undivisable numeric!")
    }
}

例如，如果我喂它，这将非常有效：

val values:Seq[(Float,Float)] = List((1,2f),(1,3f))
val avg= weightedAverage(values)

但是，如果我不将权重从Int“向上转换”到Float：

val values= List((1,2f),(1,3f)) //scalac sees it as Seq[(Int,Float)] 
val avg= weightedAverage(values)

Scala 编译器会告诉我：

错误：找不到类型的证据参数的隐式值 数值[AnyVal]
val avg= weightedAverage(values)

有没有办法解决这个问题？

我曾尝试编写一个NumericCombine 类，我用A 和B 参数化了该类，它将这些类型“组合”成一个“通用”类型AB（例如，组合Float 和@ 987654343@ 给你Float) :

abstract class NumericCombine[A: Numeric, B: Numeric] {
    type AB <: AnyVal

    def fromA(x: A): AB
    def fromB(y: B): AB
    val num: Numeric[AB]

    def plus(x: A, y: B): AB = num.plus(fromA(x), fromB(y))
    def minus(x: A, y: B): AB = num.minus(fromA(x), fromB(y))
    def times(x: A, y: B): AB = num.times(fromA(x), fromB(y))
}

并且我设法在此基础上使用 typeclass 模式编写了简单的 times 和 plus 函数，但是由于 NumericCombine 引入了路径依赖类型 AB，因此“组合”类型被证明是更多比我预想的要难。查看this 问题了解更多信息，并查看here 了解NumericCombine 的完整实现。

更新

作为对another question（完整工作演示here）的回答，已经获得了一个稍微令人满意的解决方案，但是考虑到@ziggystar 在discussion 中提出的观点，仍有一些设计改进的空间。

Answer 1

线性组合

我认为涉及通过S 类型的标量对T 类型的某些元素进行加权/缩放的更一般的任务是线性组合的任务。以下是一些任务的权重限制：

• linear combination：没有限制
• 仿射组合：权重之和为一
• canonical combination/weighted average：权重为非负数
• 凸组合：权重总和为 1 且为非负数

所以根据这种分类最一般的情况是线性组合。 根据维基百科，它要求权重 S 是一个字段，而 T 在 S 上形成一个 vector space。

编辑：您可以对类型提出的真正最一般的要求是T 在环S 上形成一个module (wiki)，或者T 是一个S-模块。

尖顶

您可以使用类型类设置这些要求。还有spire，它已经有Field 和VectorSpace 的类型类。我自己没用过，你自己去看看吧。

Float/Int 不起作用

从这个讨论中也可以明显看出，并且您已经观察到，将Float 作为权重，将Int 作为元素类型是行不通的，因为整数不会形成实数上的向量空间。您必须先将Int 提升为Float。

通过类型类推广

标量类型只有两个主要候选者，即Float 和Double。 并且主要只有Int 是推广的候选者，因此您可以将以下作为简单但不那么通用的解决方案：

case class Promotable[R,T](promote: R => T)

object Promotable {
  implicit val intToFloat = Promotable[Int,Float](_.toFloat)
  implicit val floatToDouble = Promotable[Float,Double](_.toDouble)
  implicit val intToDouble = Promotable[Int,Double](_.toDouble)

  implicit def identityInst[A] = Promotable[A,A](identity)
}As a "small" solution you could write a typeclass 

def weightedAverage[S,VS](values: Seq[(S,VS)])(implicit p: Promotable[VS,S]) = ???

Answer 2

首先你的模板是错误的。 （很抱歉，如果“模板”表达式是错误的——我是 scala 的新手）。 您的函数需要两个元素属于相同类型（ [A: Numeric] ）的元组，而不是元素具有不同类型（ [A: Numeric, B: Numeric] ）（ (Int, Float) vs (Float,浮动) )

无论如何，下面的编译器都可以编译，并希望在你用你想要的微积分填充它后能很好地工作。

import scala.collection._

def weightedSum[A: Numeric, B: Numeric](weightedValues: GenSeq[(A,B)]): (A,B) = {
  weightedValues.foldLeft((implicitly[Numeric[A]].zero, implicitly[Numeric[B]].zero)) { (z, t) =>
    (   implicitly[Numeric[A]].plus(z._1, t._1), 
        implicitly[Numeric[B]].plus(z._2, t._2)
    ) 
  } 
}

def weightedAverage[A: Numeric, B: Numeric](weightedValues: GenSeq[(A,B)]): A = {
  val (weightSum, weightedValueSum) = weightedSum(weightedValues)
  implicitly[Numeric[A]] match {
    case num: Fractional[A] => implicitly[Numeric[A]].zero
    case num: Integral[A] => implicitly[Numeric[A]].zero
    case _ => sys.error("Undivisable numeric!")
  }
}

val values1: Seq[(Float, Float)] = List((1, 2f), (1, 3f))
val values2: Seq[(Int, Float)] = List((1, 2f), (1, 3f))

val wa1 = weightedAverage(values1)
val wa2 = weightedAverage(values2)