mercredi 2 avril 2008

Une classe pour une fonction

Une petite idée comme ça : plutôt que d'appeler directement une fonction, comme ici (loi des gaz parfaits) :

def compute_p v, n, t
r = 8.314
p = (n*r*t)/v
return p
end
puts "p = #{compute_p(1.0, 10.0, 273.5)}"


Pourquoi ne pas créer une classe, représentant cette fonction ? En effet, on peut alors définir un certain nombre d'options à l'exécution "internes" à notre fonction (ici, j'ai mis des exemples simples : print pour un affichage console, et clock pour retarder l'exécution d'un temps donné). On pourrait aussi sécuriser les arguments (non fait ici...) par rapport à des contraintes internes à la classe (ex : température > 0, autre ?) ou décider de remplacer certains arguments sous certaines conditions, éventuellement externes. Et bien d'autres choses, pour des problématiques concurrentielles... Des idées ?


class Compute_p_class

# Initializing the arguments as attributes
def initialize args
@v = args[:v]
@n = args[:n]
@t = args[:t]
@@r = 8.314
@opt = []
@opt_args = {}
end


# To add an option at execution
def add_option option, argopt = nil
@opt.push option
@opt_args[option] = argopt
end

# Wait for @opt_args[:clock] s before executing
def option_clock
t_beg = Time.now
t = t_beg
if @opt.include? :clock then
while t < t_beg + @opt_args[:clock]
t = Time.now
end
end
end

# Verbose-like
def option_print
if @opt.include? :print then
puts "Executing function Compute_p"
puts "with arguments"
puts "v = #{@v}"
puts "n = #{@n}"
puts "t = #{@t}"
end
end

# Execution after options
def execute
# Options management
option_print
option_clock
# Function core
p = (@n*@@r*@t)/@v
return p
end
end

values = {:v => 1.0, :n => 10.0, :t => 273.5}
calcul = Compute_p_class.new values
calcul.add_option :clock, 5.0
calcul.add_option :print

puts "p = #{calcul.execute}"

0 commentaires: