Méthodes d’opérateurs

Fait partie de la section Programmation orientée objet du Journey Ruby de Coddy. Leçon 38 sur 57.

La plupart des opérateurs Ruby sont des méthodes. a + b appelle a.+(b), donc une classe définit + comme n’importe quelle autre méthode. Les opérations arithmétiques sur des objets-valeurs renvoient un nouvel objet et ne modifient aucun des deux opérandes :

class Vector
  attr_reader :x, :y

  def initialize(x, y)
    @x = x
    @y = y
  end

  def +(other)
    Vector.new(x + other.x, y + other.y)
  end

  def to_s
    "(#{x}, #{y})"
  end
end

a = Vector.new(1, 2)
b = Vector.new(3, 4)
puts a + b
puts a

Sortie :

(4, 6)
(1, 2)

Le membre de droite peut être un autre type de valeur, comme un nombre pour effectuer une mise à l’échelle. Le moins unaire est la méthode -@ :

class Vector
  attr_reader :x, :y

  def initialize(x, y)
    @x = x
    @y = y
  end

  def -(other)
    Vector.new(x - other.x, y - other.y)
  end

  def *(factor)
    Vector.new(x * factor, y * factor)
  end

  def -@
    Vector.new(-x, -y)
  end

  def to_s
    "(#{x}, #{y})"
  end
end

v = Vector.new(3, 4)
puts v * 2
puts v - Vector.new(1, 1)
puts(-v)

Sortie :

(6, 8)
(2, 3)
(-3, -4)

Une fois que + existe, += fonctionne aussi, car a += b signifie a = a + b. sum fonctionne également lorsqu’on lui fournit une valeur de départ de votre classe :

class Money
  attr_reader :cents

  def initialize(cents)
    @cents = cents
  end

  def +(other)
    Money.new(cents + other.cents)
  end

  def to_s
    format("$%.2f", cents / 100.0)
  end
end

total = Money.new(0)
total += Money.new(250)
total += Money.new(199)
puts total
puts [Money.new(100), Money.new(5)].sum(Money.new(0))

Sortie :

$4.49
$1.05

<=> est également un opérateur. Avec Comparable, il permet de comparer et de trier les objets Money, et un opérateur peut refuser un opérande incompatible en levant une exception, comme le font les nombres :

class Money
  include Comparable
  attr_reader :cents, :currency

  def initialize(cents, currency)
    @cents = cents
    @currency = currency
  end

  def +(other)
    raise ArgumentError, "cannot add #{other.currency} to #{currency}" unless other.currency == currency

    Money.new(cents + other.cents, currency)
  end

  def <=>(other)
    cents <=> other.cents
  end
end

puts Money.new(500, "EUR") > Money.new(300, "EUR")
begin
  Money.new(1, "EUR") + Money.new(1, "USD")
rescue ArgumentError => e
  puts e.message
end

Sortie :

true
cannot add USD to EUR

Défi

Facile

Complétez la classe Vector. Définissez + et - pour deux vecteurs, * pour un vecteur et un nombre, le moins unaire -@, == comparant les deux coordonnées, ainsi que to_s, qui renvoie (4, 6). length renvoie la longueur du vecteur avec Math.sqrt.

Le code fourni lit des expressions : 1,2 + 3,4, 1,2 - 3,4, 1,2 * 3, neg 1,2 et 1,2 == 1,2. Il affiche chaque résultat et, pour les résultats vectoriels, également length 7.21 avec deux décimales.

Votre code doit se trouver dans vector.rb. main.rb contient le code d'entrée/sortie fourni et ne peut pas être modifié.

Essayez vous-même

require_relative 'vector'

# Code d'entrée/sortie fourni : le garder tel quel
input = []
while (line = gets)
  input << line.chomp
end
def vec(text)
  Vector.new(*text.split(",").map(&:to_i))
end

input.each do |line|
  parts = line.split
  result = if parts[0] == "neg" then -vec(parts[1])
           else
             a = vec(parts[0])
             case parts[1]
             when "+" then a + vec(parts[2])
             when "-" then a - vec(parts[2])
             when "*" then a * parts[2].to_i
             else a == vec(parts[2])
             end
           end
  puts result
  puts format("length %.2f", result.length) if result.is_a?(Vector)
end