转换函数以处理Double和Float ...使用FloatingPoint类型？

Question

我在SO上看过类似的问题，但它并没有回答我在这里问的一切。

我有这样的功能：

  func myFunctionDouble (_ valores:[Double] = []) -> Array<Double> {

    let numeroItens = valores.count
    var c = [Double](repeating: 0,
                     count: numeroItens)

    let factor : Double = Double.pi / Double(numeroItens)

    for i in 0..<numeroItens {
      var sum : Double = 0
      for j in 0..<numeroItens {
        sum = sum + valores[j] * cos ((Double(j) + 0.5) * Double(i) * factor)
      }
      c[i] = sum
    }
    return c;
  }

我想转换这个函数来处理Double和Float。

我想用Double替换FloatingPoint，但它根本不起作用，给我一堆错误。

没有FloatingPoint.pi或数组c不能被声明

var c = [FloatingPoint](repeating: 0, count: numeroItens)

有没有办法做到这一点？

更重要的是，我如何声明一个var或一个数组是FloatingPoint类型，我的意思是，接受Float和Double？

Answer 1

按照Rob's回答How to use FloatingPoint generic type for Float/Double的说明，您可以执行以下操作：

import Darwin // minimal necessary import
// importing Foundation, AppKit or UIKit also implicitly import Darwin

protocol Cosineable {
    func cosine() -> Self
}

extension Float: Cosineable {
    func cosine() -> Float { return cos(self) }
}

extension Double: Cosineable {
    func cosine() -> Double { return cos(self) }
}

func myFunction<T: FloatingPoint>(_ valores:[T] = []) -> Array<T> where T: ExpressibleByFloatLiteral, T: Cosineable {

    let numeroItens = valores.count
    var c = [T](repeating: 0,
                     count: numeroItens)

    let factor : T = T.pi / T(numeroItens)

    for i in 0..<numeroItens {
        var sum : T = 0
        for j in 0..<numeroItens {
            sum += valores[j] * ((T(j) + 0.5) * T(i) * factor).cosine()
        }
        c[i] = sum
    }
    return c
}

Answer 2

添加到@rmaddy的解决方案中，您可以通过使用更高阶函数来消除所有“噪声”，即计算所需的所有事物，但实际上并非特定于您的计算，因此可以大大简化您的代码。

func myFunction<T: FloatingPoint>(_ valores:[T] = []) -> Array<T>
    where T: ExpressibleByFloatLiteral, T: Cosineable {
    let factor: T = T.pi / T(valores.count)

    return valores.indices.map { i in
        return valores.enumerated()
            .map { (offset, element) in
                element * ((T(offset) + 0.5) * T(i) * factor).cosine()
            }
            .reduce(0, +)
    }
}

从这里开始，您可以更好地标记术语，并提供更多关于这些术语的背景信息。

element * ((T(offset) + 0.5) * T(i) * factor).cosine()这个术语对于单个表达来说太复杂了。为什么0.5？什么是factor？我们为什么选择cosine？这是非常不明显的。这段代码的陌生人不仅不会理解这一点，而且随着时间的推移，你自己会忘记这一点并成为代码的“陌生人”。