Basic arithmetic operations with user input

Question

I want to make a four-functioning calculator. I tried to make methods that would store operations.

def mul
  puts num1*num2
end

def div
  puts num1/num2
end

def sub
  puts num1-num2
end

def add
  puts num1+num2
end

num1=gets.chomp.to_f
op=gets.chomp
num2=gets.chomp.to_f

puts "Multiplication=mul\n Addition=add\n Subtract=sub\n Division=div"
puts ("This is your answer"+num1+op+num2)

But I couldn't make the calculator.

I tried running the code, but it won't work. Can someone help?

Answer 1

Best Way to do so, is

def perform_operation(op, a, b)
  op = { 'add' => '+', 'sub' => '-', 'mul' => '*', 'div' => '/' }[op]
  a.send(op, b)
end

num1=gets.chomp.to_f
op=gets.chomp
num2=gets.chomp.to_f

puts "This is your answer", perform_operation(op, num1, num2)

If your op is +, -, * or / passed by input you can directly do it without method like below,

puts "This is your answer", num1.send(op, num2)

Answer 2

You can't use local variables defined outside a method within that method. Instead, you have to pass it as an argument:

def mul(num1, num2)
  puts num1 * num2
end

You also don't have to use the same variable names, use whatever makes sense in the context of the method:

def mul(a, b)
  puts a * b
end

mul(2, 3)
# prints 6

Methods usually become more versatile if they do one thing. The above implementation multiplies a and b and then prints the result via puts. Let's move the printing outside the method:

def mul(a, b)
  a * b
end

puts mul(2, 3)
# prints 6

We can now perform actual calculations:

x = mul(2, 3) #=> 6
y = mul(2, 5) #=> 10
puts mul(x, y)
# prints 60

This wouldn't have been possible with the variant which incorporated puts.

---

With user input and output: (using whole numbers for demonstration purposes)

print "first factor: "
num1 = gets.to_i

print "second factor: "
num2 = gets.to_i

puts "#{num1} * #{num2} = #{mul(num1, num2)}"

Note that #{...} is needed to interpolate other values.

Example session:

first factor: 2
second factor: 3
2 * 3 = 6

---

To have different output based on a given operator, you need a conditional, e.g. a case statement:

op = gets.chomp

case op
when 'mul'
  puts mul(num1, num2)
when 'add'
  puts add(num1, num2)
# ...
end

---

Hope this will get you started.

Answer 3

Once you defined the methods with parameters, for example:

def sub(x, y)
  x - y
end

def add(x, y)
  x + y
end

Once you gat the variables set by user input (I'm assigning by hard coding just to show):

op = "add".to_sym # or user input
num1 = 10 # or user input
num2 = 20 # or user input

You can use the case expression to select the result to show. For example:

res = case op
  when :add
    add(num1, num2)
  when :sub
    sub(num1, num2)
end

So you can show the result as:

puts res

As mentioned, you can also call the method on the user input using send:

• How to call methods dynamically based on their name?
• Ruby difference between send and instance_eval?

Answer 4

Using heredoc and proc

def mul(num1, num2)
  num1 * num2
end

def div(num1, num2)
  num1 / num2
end

def sub(num1, num2)
  num1 - num2
end

def add(num1, num2)
  num1 + num2
end

puts 'First number'
num1 = gets.to_f

puts 'Second number'
num2 = gets.to_f

puts <<-OPERATORS
Multiplication = mul
Addition = add
Subtract = sub
Division = div
OPERATORS

op = method(gets.chomp).to_proc

puts "This is your answer: #{op.call(num1, num2)}"

How it works on the example of String#downcase:

downator = :downcase.to_proc
downator.call('WORD') #=> "word"

# It is equal to
'WORD'.downcase #=> "word"

It is because downator stores block proc { |arg| arg.downcase }

In practice, this property is often used for operations with arrays, for example:

['WORD', 'STRING'].map(&:downcase) #=> ["word", "string"]

# It is equal to
['WORD', 'STRING'].map { |arg| arg.downcase } #=> ["word", "string"]