Расширение Swift Array для стандартного отклонения

Question

Мне часто приходится вычислять среднее и стандартное отклонение для числовых массивов. Поэтому я написал небольшой протокол и расширения для числовых типов, которые, похоже, работают. Я просто хотел бы получить обратную связь, если что-то не так с тем, как я это сделал. В частности, мне интересно, есть ли лучший способ проверить, может ли тип быть отличным как Double, чтобы избежать необходимости переменной asDouble и конструктором init(_:Double).

Я знаю, что есть проблемы с протоколами, которые допускают арифметику, но это, похоже, работает нормально и избавляет меня от установки стандартной функции отклонения в классы, которые в ней нуждаются.

protocol Numeric { 
    var asDouble: Double { get } 
    init(_: Double) 
} 

extension Int: Numeric {var asDouble: Double { get {return Double(self)}}} 
extension Float: Numeric {var asDouble: Double { get {return Double(self)}}} 
extension Double: Numeric {var asDouble: Double { get {return Double(self)}}} 
extension CGFloat: Numeric {var asDouble: Double { get {return Double(self)}}} 

extension Array where Element: Numeric { 

    var mean : Element { get { return Element(self.reduce(0, combine: {$0.asDouble + $1.asDouble})/Double(self.count))}} 

    var sd : Element { get { 
     let mu = self.reduce(0, combine: {$0.asDouble + $1.asDouble})/Double(self.count) 
     let variances = self.map{pow(($0.asDouble - mu), 2)} 
     return Element(sqrt(variances.mean)) 
    }} 
} 

редактировать: Я знаю, что это своего рода бессмысленно получить [Int].mean и sd, но я мог бы использовать числовое в другом месте, так что это для последовательности ..

редактировать: в @Severin Pappadeux отметил, дисперсия может выражаться таким образом, чтобы избежать тройного прохода по массиву - значит, тогда значение карты означает среднее значение. Вот окончательное расширение стандартного отклонения

extension Array where Element: Numeric { 

    var sd : Element { get { 
     let sss = self.reduce((0.0, 0.0)){ return ($0.0 + $1.asDouble, $0.1 + ($1.asDouble * $1.asDouble))} 
     let n = Double(self.count) 
     return Element(sqrt(sss.1/n - (sss.0/n * sss.0/n))) 
    }} 
} 

Answer 1

В Swift 3 вы можете (или не можешь) быть в состоянии сохранить себя некоторые дублирования протокола с плавающей точкой, но в противном случае, что вы делаете, это точно.

Answer 2

Не то, что я знаю Свифт, но от Числового POV вы делаете это немного нерационально

В принципе, вы делаете два проход (на самом деле, три) по массиву, чтобы вычислить два значения, где один проход должно быть достаточно. Vairance может быть выражено как E (X) - Е (Х) , так что в какой-то псевдо-код:

tuple<float,float> get_mean_sd(data) { 
    float s = 0.0f; 
    float s2 = 0.0f; 
    for(float v: data) { 
     s += v; 
     s2 += v*v; 
    } 
    s /= count; 
    s2 /= count; 

    s2 -= s*s; 
    return tuple(s, sqrt(s2 > 0.0 ? s2 : 0.0)); 
} 

Answer 3

Там на самом деле класс, который обеспечивает эту функциональность уже - называется NSExpression. Вы можете уменьшить размер и сложность кода, используя это вместо этого. Для этого класса довольно много вещей, но простая реализация того, что вы хотите, заключается в следующем.

let expression = NSExpression(forFunction: "stddev:", arguments: [NSExpression(forConstantValue: [1,2,3,4,5])]) 
let standardDeviation = expression.expressionValueWithObject(nil, context: nil) 

Вы также можете вычислить среднее значение и многое другое. Информация здесь: http://nshipster.com/nsexpression/

Answer 4

Swift расширение 4 Массив элементов с плавающей запятой:

extension Array where Element: FloatingPoint { 

    func sum() -> Element { 
     return self.reduce(0, +) 
    } 

    func avg() -> Element { 
     return self.sum()/Element(self.count) 
    } 

    func std() -> Element { 
     let mean = self.avg() 
     let v = self.reduce(0, { $0 + ($1-mean)*($1-mean) }) 
     return sqrt(v/(Element(self.count) - 1)) 
    } 

}