Comment puis-je faire de l'écart type dans Ruby?

module Enumerable

    def sum
      self.inject(0){|accum, i| accum + i }
    end

    def mean
      self.sum/self.length.to_f
    end

    def sample_variance
      m = self.mean
      sum = self.inject(0){|accum, i| accum +(i-m)**2 }
      sum/(self.length - 1).to_f
    end

    def standard_deviation
      Math.sqrt(self.sample_variance)
    end

end 

De le tester:

a = [ 20, 23, 23, 24, 25, 22, 12, 21, 29 ]
a.standard_deviation  
# => 4.594682917363407

---

01/17/2012:

de fixation "sample_variance" merci à Dave Sag

La réponse donnée ci-dessus est élégant, mais a une légère erreur. N'étant pas des stats de la tête moi-même je m'assis et lire en détail un certain nombre de sites web et trouvé celui-ci a donné la plus compréhensible explication de comment calculer un écart-type. http://sonia.hubpages.com/hub/stddev

L'erreur dans la réponse ci-dessus est dans le sample_variance méthode.

Voici ma version corrigée, avec une simple unité de test qui montre que cela fonctionne.

dans ./lib/enumerable/standard_deviation.rb

#!usr/bin/ruby

module Enumerable

  def sum
    return self.inject(0){|accum, i| accum + i }
  end

  def mean
    return self.sum / self.length.to_f
  end

  def sample_variance
    m = self.mean
    sum = self.inject(0){|accum, i| accum + (i - m) ** 2 }
    return sum / (self.length - 1).to_f
  end

  def standard_deviation
    return Math.sqrt(self.sample_variance)
  end

end

dans ./test à l'aide de nombres dérivés à partir d'une simple feuille de calcul.

#!usr/bin/ruby

require 'enumerable/standard_deviation'

class StandardDeviationTest < Test::Unit::TestCase

  THE_NUMBERS = [1, 2, 2.2, 2.3, 4, 5]

  def test_sum
    expected = 16.5
    result = THE_NUMBERS.sum
    assert result == expected, "expected #{expected} but got #{result}"
  end

  def test_mean
    expected = 2.75
    result = THE_NUMBERS.mean
    assert result == expected, "expected #{expected} but got #{result}"
  end

  def test_sample_variance
    expected = 2.151
    result = THE_NUMBERS.sample_variance
    assert result == expected, "expected #{expected} but got #{result}"
  end

  def test_standard_deviation
    expected = 1.4666287874
    result = THE_NUMBERS.standard_deviation
    assert result.round(10) == expected, "expected #{expected} but got #{result}"
  end

end

L'présenté le calcul ne sont pas très efficaces, car ils ont besoin de plusieurs (au moins deux, mais souvent trois parce que vous voulez généralement à la moyenne actuelle en plus de std-dev) passe à travers le tableau.

Je sais que Ruby n'est pas l'endroit pour chercher de l'efficacité, mais c'est mon application qui calcule la moyenne et l'écart-type avec un seul passage sur les valeurs de la liste:

module Enumerable

  def avg_stddev
    return nil unless count > 0
    return [ first, 0 ] if count == 1
    sx = sx2 = 0
    each do |x|
      sx2 += x**2
      sx += x
    end
    [ 
      sx.to_f  / count,
      Math.sqrt( # http://wijmo.com/docs/spreadjs/STDEV.html
        (sx2 - sx**2.0/count)
        / 
        (count - 1)
      )
    ]
  end

end

Si les dossiers à la main sont de type Integer ou Rational, vous pouvez calculer la variance à l'aide de Rational au lieu de Float pour éviter les erreurs introduites par l'arrondissement.

Par exemple:

def variance(list)
  mean = list.reduce(:+)/list.length.to_r
  sum_of_squared_differences = list.map { |i| (i - mean)**2 }.reduce(:+)
  sum_of_squared_differences/list.length
end

(Il serait prudent d'ajouter un cas spécial de manutention pour vider les listes et les autres cas de bord.)

Ensuite la racine carrée peut être définie comme:

def std_dev(list)
  Math.sqrt(variance(list))
end

Ou que diriez-vous:

class Stats
    def initialize( a )
        @avg = a.count > 0 ? a.sum / a.count.to_f : 0.0
        @stdev = a.count > 0 ? ( a.reduce(0){ |sum, v| sum + (@avg - v) ** 2 } / a.count ) ** 0.5 : 0.0
    end
end