Robert, I was actually reading the summation wiki and they had a few
code examples in C++/Java… I thought I’d goof a bit and write
something out in ruby. Of course, I hit the roadblock when trying to
pass math operators(or methods rather) to a method…
I got this far
def sigma(floor, to_do, cap)
end
puts sigma(4, ^2, 20)
I will fiddle with your suggestions and continue with my sigma
Don’t read on if you first want to experiment yourself.
On 17.01.2007 17:48, Neutek wrote:
Robert, I was actually reading the summation wiki and they had a few
code examples in C++/Java… I thought I’d goof a bit and write
something out in ruby. Of course, I hit the roadblock when trying to
pass math operators(or methods rather) to a method…
What is the “summation wiki”? Are you referring to this page?
If yes, here are some more ways:
plain values
sum = (m…n).inject(0){|s,x| s + x}
with a function
f = lambda {|i| i * 2}
sum = (m…n).inject(0){|s,x| s + f[x]}
in a method
def sum(m, n, f)
(m…n).inject(0){|s,x| s + f[x]}
end
s = sum( 1, 2, lambda {|x| x * 2} )
etc.
Advantage of using lambdas is that they are more flexible than method
names and can contain arbitrary calculations.
sum = (m…n).inject(0){|s,x| s + f[x]}
Advantage of using lambdas is that they are more flexible than method
names and can contain arbitrary calculations.
Kind regards
robert
PS: Please don’t top post.
What’s top post? (sorry, I’m new to google groups --I put my reply at
the bottom if this is what you meant )
I’ll read through your example now but figured what I worked on in the
interim was worth posting…
#works
def test(a, to_do, b)
return a.send(to_do, b)
end
puts test(2, :**, 3)
#does not work when trying to send an entire mathematical expresion as
a param
def sigma(floor, to_do, cap)
x = 0
floor.upto(cap) {|i|
x += i.send(to_do)
}
return x
end
puts sigma(4, :**2, 20)
#does not work… but another example of what I would expect
}
return x
end
puts sigma(4, lambda{|x| x ** 2}, 20)
Thanks a million!
Basically if you think this further through, what you are trying to do
is already part of Ruby’s standard lib. The method is #inject. I think
I used it in one of my postings. Your piece above becomes
puts (4…20).inject(0) {|s,x| s + x ** 2}
or, to more directly translate using #upto
require ‘enumerator’
puts 4.to_enum(:upto, 20).inject(0) {|s,x| s + x ** 2}
#does not work when trying to send an entire mathematical expresion as
a param
def sigma(floor, to_do, cap)
x = 0
floor.upto(cap) {|i| #x += i.send(to_do)
x += to_do[i]
}
return x
end
puts sigma(4, lambda{|x| x ** 2}, 20)
Thanks a million!
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.