Mean method

[Älphä Blüë]

I'm working on a lot of math in my projects so I thought I would convert
over a few methods I used in other languages that I created and port
them to ruby.

Here's a mean method which allows you to return either:

a) arithmetic mean
b) geometric mean
c) harmonic mean

http://pastie.org/553287

Enjoy.

 

[Chuck Remes]

I'm working on a lot of math in my projects so I thought I would =20
convert
over a few methods I used in other languages that I created and port
them to ruby.

Here's a mean method which allows you to return either:

a) arithmetic mean
b) geometric mean
c) harmonic mean

http://pastie.org/553287

The pastie is missing your extension of Array to add the #sum method, =20=

so the example doesn't work. Also, unless #sum returns a float then it =20=

is possible for your arithmetic mean to return a result truncated to =20
the nearest integer due to the way Ruby's division works with integers.

Lastly, I have a style suggestion. In your parameter sanity checks, I =20=

think this reads easier:

raise "mean(#{an_array}) error: #{an_array} is not an array." unless =20
an_array.is_a? Array

raise "mean(#{an_array},#{i_type}) error:: #{i_type} mean type is not =20=

an integer." unless i_type.is_a? Fixnum

raise "mean(#{an_array},#{i_type}) error: invalid mean type =20
((#{i_type}) set. Only 1..3 valid." unless (1..3).include? i_type

Thanks for sharing your code.

cr=

 

[Brian Candler]

http://pastie.org/553287

Are you posting here because you want comments/suggestions? If so,
here's my 2c.

(1) Passing enumerated values 1,2,3 is not very Ruby-like. If you want
to go this way, then I'd suggest symbols: :arithmetic, :geometric,
:harmonic

(2) However, IMO it's also code smell if you write something like

case A
when X
.. do one thing
when Y
.. do another thing
... etc
end

There's usually a better way to ask directly for what you want.

Suggestions:

(a) add some methods directly to class Array, in the same way as 'sum'

class Array
def arithmetic_mean
self.sum / self.size
end

def geometric_mean
... etc
end
end

puts [1,2,3,4,5].arithmetic_mean

This is perfectly fine within your own apps, but modifying core classes
may not be acceptable in a shared library (depending on who your target
audience is)

(b) wrap an array with an object which does the calculation

class Mean
def initialize(arr)
@arr = arr
end

def arithmetic
@arr.sum / @arr.size
end

... etc
end

puts Mean([1,2,3,4,5]).arithmetic

Note that creating an object like this is a cheap operation in Ruby.
You're not copying the array elements, just a reference to the array
itself.

(3) It is considered extremely bad form to write

if !an_array.is_a? Array: raise "mean(#{an_array}) error: #{an_array}
is not an array." end

You should simply leave this out. This lets the user pass in any object
which responds to the particular methods you call on it (each, sum,
size). This is the "duck typing" principle - if someone wants to create
an object which behaves like an Array, even though it is not actually an
Array, why should you forbid them from using it?

If they pass in an incompatible object, Ruby will generate an exception
for you anyway. Admittedly it might not be quite as obvious what's
happening, but it will typically be something along the lines of

NoMethodError: object does not respond to 'sum'

which tells you exactly what the problem is.

(4) You can rewrite the following using inject:

an_array.each do |a|
n_sum += (1.0 / a)
end

(5) If I were you, I would rewrite this not to use sum and size, but
just to iterate over the collection using 'each' (or something which in
turn calls 'each', like 'inject'), calculating the total and count as
you go. This would allow your code to work on any object which is
Enumerable, such as

(1..5).arithmetic_mean

Regards,

Brian.

 

[Älphä Blüë]

thanks everyone - looking over the suggestions and rewriting it to be
more polished.

 

[Älphä Blüë]

Okay round 2,..

Let me know what you think.

http://pastie.org/553287

 

[Brian Candler]

Let me know what you think.

http://pastie.org/553287

Mean.new([1,2,3,4,5]).arithmetic

NameError: undefined local variable or method `count_of_num' for
#<Mean:0xb7bc6904 @arr=[1, 2, 3, 4, 5]>
from (irb):25:in `arithmetic'
from (irb):36
from :0

 

[Älphä Blüë]

Sorry, Brian check again.

I hadn't pasted the right code in. The count_of_num was changed to
arr_size

 

[Brian Candler]

Here's an approach which avoids to_a and size entirely, and iterates
over the collection just once:

class Mean
def initialize(arr)
@arr = arr
end

def arithmetic
count, sum = @arr.inject([0, 0.0]) { |(c,s),e| [c+1, s+e] }
sum/count
end

def geometric
count, product = @arr.inject([0, 1.0]) { |(c,s),e| [c+1, s*e] }
product ** (1.0/count)
end
end

However you can argue that it's both excessively terse and not as
efficient, and I wouldn't argue. If the main application of this is to
handle Arrays, then going for the full generality of Enumerable isn't
necessary.

It's a learning exercise for us both

Cheers,

Brian.

 

[Älphä Blüë]

I adjusted the code a bit to handle the size factor with @size in
initialize (code changed if you refresh pastie).

My main use is really for arrays but I like making things modular and
useful. I'm almost finished with the standard deviation class which
includes mean..

I perform a lot of advanced mathematics and statistical analysis so I
need some heavier methods here and there..

As I'm still new to ruby this is a great lesson for me as well,
especially with regards to code polishing and adapting to rubyism code
writing.

 

[Älphä Blüë]

Okay on Standard Deviation..

One segment I'm trying to change is:

@arr.each do |a|
n += ((a - mean)**2)
std = Math.sqrt(n / @size)
end

into something like this...?

Math.sqrt( (@arr.inject {|a,b| ((a - @mean)**2) + ((b - @mean)**2) }) /
@size)

.. but I don't think I have the inject working properly..

From my understanding of inject, using above..

a = first instance of array
b = subsequent instances of array

so if @arr = [1,2,3,4,5]

@arr.inject {|a,b| ((a - @mean)**2) + ((b - @mean)**2)}
1-@mean**2 ..reference for a
+
2-@mean**2 ..reference for b
+
3-@mean**2 ..reference for b
+
4-@mean**2 ..reference for b
+
5-@mean**2 ..reference for b

 

[Brian Candler]

From my understanding of inject, using above..

a = first instance of array
b = subsequent instances of array

No, not exactly. You are using the new 1.9 usage (possibly also 1.8.7):

foo.inject { |a,b| ... }

a is the first element of the array in the first iteration only. For
subsequent iterations, a is the value of the previous block evaluation.

It may be clearer if you stick to the old usage:

foo.inject(init) { |a,b| ... }

In the first invocation, a is init and b is the first element of the
array. For the next invocation, a is the previous block value and b is
the next element of the array. And so on.

Looking at your initial code:

@arr.each do |a|
n += ((a - mean)**2)
std = Math.sqrt(n / @size)
end

This is strange. You're calculating a value in every iteration and
assigning it to std, but then throwing it away apart from the last one.
Shouldn't this go outside the loop?

n = 0
@arr.each do |a|
n += ((a - mean)**2)
end
std = Math.sqrt(n / @size)

If that's correct, then the solution becomes obvious:

n = @arr.inject(0) { |accum,elem| accum + (elem-mean)**2 }
std = Math.sqrt(n / @size)

 

[Chuck Remes]

I adjusted the code a bit to handle the size factor with @size in
initialize (code changed if you refresh pastie).

My main use is really for arrays but I like making things modular and
useful. I'm almost finished with the standard deviation class which
includes mean..

I perform a lot of advanced mathematics and statistical analysis so I
need some heavier methods here and there..

As I'm still new to ruby this is a great lesson for me as well,
especially with regards to code polishing and adapting to rubyism code
writing.

I've written some code to compute skew and kurtosis (the 3rd and 4th =20
moments) if you want a copy. I'll send you my whole class if you'd =20
like. It's a bit hard to follow because I heavily optimized it to =20
cache results and/or pass around intermediate results.

cr

 

[Älphä Blüë]

This is the new Standard Deviation class I created. It's very
simplified and works really well.

class Stddev
def initialize(arr)
@arr = arr
@size = @arr.to_a.size
end

def sum
@arr.inject {|a,b| a + b }
end

def sumofx
@arr.inject {|a,b| a + b**2}
end

def newcalc
Math.sqrt((sumofx-((sum * sum)/@size))/(@size-1).to_f)
end
end

 

[Älphä Blüë]

As a test you would do:

a = [1,2,3,4,5]

Stddev.new(a).newcalc

You can also do Stddev.new(1..5).newcalc

You can rename the newcalc to anything you want..

 

[Älphä Blüë]

This is written a bit better and more readable:

class Stddev
def initialize(arr)
@arr = arr
@size = @arr.to_a.size
end

def sumofx
@arr.inject {|a,b| a + b }
end

def sumofxsquared
@arr.inject {|a,b| a + b**2}
end

def calculate
Math.sqrt((sumofxsquared-((sumofx * sumofx)/@size))/(@size-1).to_f)
end
end

a = [1,2,3,4,5]

Stddev.new(a).calculate

 

[Matthias Reitinger]

I adjusted the code a bit to handle the size factor with @size in
initialize (code changed if you refresh pastie).

Unfortunately this produces wrong results when the array changes in
between. Consider this:

array = [1,2,3,4]
mean = Mean.new(array)
puts mean.arithmetic # => 2.5
array << 5
puts mean.arithmetic # => 3.75
puts Mean.new(array).arithmetic # => 3.0

As the size is only determined once in Mean#initialize, subsequent changes
of the array (size) go unnoticed. This behaviour should at least be
documented.

-Matthias