Swift Array Erweiterung für Standardabweichung

Question

Ich benötige häufig die Berechnung von Mittelwert und Standardabweichung für numerische Arrays. Also habe ich ein kleines Protokoll und Erweiterungen für numerische Typen geschrieben, die zu funktionieren scheinen. Ich hätte gerne Feedback, wenn etwas nicht stimmt mit dem, was ich getan habe. Insbesondere frage ich mich, ob es eine bessere Möglichkeit gibt zu überprüfen, ob der Typ als Double umgewandelt werden kann, um die asDouble Variable und den init(_:Double) Konstruktor zu vermeiden.

Ich weiß, es gibt Probleme mit Protokollen, die für Arithmetik zulassen, aber das scheint in Ordnung zu funktionieren und erspart mir, die Standardabweichungsfunktion in Klassen zu setzen, die es brauchen.

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

edit: Ich weiß, es irgendwie sinnlos ist [Int].mean und sd zu bekommen, aber ich könnte numerisch an anderer Stelle verwenden, so dass es für die Konsistenz ist ..

edit: wie @Severin Pappadeux darauf hingewiesen, Varianz in einer Weise ausgedrückt werden, die den Triple-Pass auf dem Array vermeidet - bedeuten dann Karte dann bedeuten. Hier ist die letzte Standardabweichung Erweiterung

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

In Swift 3 Sie können (oder auch nicht) in der Lage sein, sich mit dem Floatingpoint-Protokoll einige Überschneidungen zu retten, aber sonst, was Sie tun, ist hier genau richtig.

Answer 2

Nicht, dass ich weiß, Swift, aber von Numerik POV bist du es ein wenig ineffektiv

Im Grunde tun, sind Sie zwei Pässe zu tun (eigentlich drei) über die Anordnung zwei Werte zu berechnen, wobei ein Durchgang sollte genug sein. Vairance könnte als E (X) ausgedrückt werden - E (X) , so in einigen Pseudo-Code:

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

Es gibt tatsächlich eine Klasse, die diese Funktionalität bereits bietet - genannt NSExpression. Sie können Ihre Code-Größe und Komplexität reduzieren, indem Sie stattdessen verwenden. Es gibt eine Menge Zeug in dieser Klasse, aber eine einfache Implementierung von dem, was Sie wollen, ist wie folgt.

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

Sie können auch Mittelwert berechnen, und vieles mehr. Info hier: http://nshipster.com/nsexpression/

Answer 4

Swift 4 Array-Erweiterung mit Floatingpoint-Elemente:

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

}