将功能转换为处理double和float ..使用浮点类型

Question

我在此上看到了类似的问题，但是它没有回答我在这里要求的所有问题。

我有这样的功能：

  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;
  }

我想转换此功能以处理双重和浮动。

我考虑过用FloatingPoint替换Double，但它根本不起作用，并给我很多错误。

没有FloatingPoint.pi或数组c不能像

那样声明

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

有办法做到吗？

更重要的是，我如何将FloatingPoint类型的VAR或数组声明，我的意思是同时接受Float和Double？

Answer 1

遵循Rob回答的示例，涉及如何使用floatingpoint通用类型进行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()是faaaaararrrrr，对于单个表达式来说太复杂了。为什么0.5？什么是factor？我们为什么要参加cosine？这是非常不可思议的。该代码的陌生人不仅不了解这一点，而且随着时间的流逝，您自己会忘记这一点，成为代码的"陌生人"。