Merge pull request #1 from daigaku-ruby/add-chapter-numbers

Add chapter numbers

Author: paulgoetze

2_Numbers/1_The_different_types_of_numbers/solution.rb

@@ -0,0 +1,5 @@
+# e.g.:
+fixnum = 5
+bignum = 100_000_000_000_000_000_000
+rational = Rational(2, 7)
+complex = Complex(0.1, 2.5)

2_Numbers/1_The_different_types_of_numbers/solution_spec.rb

@@ -0,0 +1,22 @@
+require 'rspec'
+
+describe "Your code" do
+  [['solution::code']]
+
+  {
+    fixnum: Fixnum,
+    bignum: Bignum,
+    rational: Rational,
+    complex: Complex
+  }.each do |variable, class_name|
+    it "defines a variable with name \"#{variable}\"" do
+      expect(local_variables.include?(variable)).to be true
+    end
+
+    if local_variables.include?(variable)
+      it "defines a variable \"#{variable}\" which is a #{class_name}" do
+        expect(eval(variable.to_s).class).to eq class_name
+      end
+    end
+  end
+end

2_Numbers/1_The_different_types_of_numbers/task.md

@@ -0,0 +1,83 @@
+# Types of numbers
+
+---
+
+*You will learn:*
+- which types of numbers are available in Ruby
+- how to create a certain type of number
+- different ways to create a number
+
+---
+
+Ruby has following types of numbers: *Integer*, *Float*, *Rational*, and *Complex*.
+
+## Integers
+
+An *Integer* represents a *whole number*.
+You can create an Integer by declaring the number, like `2000` or `-42`.
+Ruby allows you to write more readable numbers by using underscores, e.g. `1_000_000`.
+Using the underscore style does not change the value of an integer, so `2_000` is
+perfectly the same as `2000`.
+
+Another way to create an Integer is by calling `Integer()` with a parameter, e.g.:
+
+`  Integer(3)`   *# => 3*
+`  Integer('3')` *# => 3*
+
+Internally, Ruby uses two different classes for Integers. Dependent on how big the
+Integer is it uses a *Fixnum* or a *Bignum*. You don't have to worry about which class to
+use, Ruby is taking care of this for you!
+
+However, you can check which class Ruby uses for your number by calling the `class`
+method on your number. Open a new terminal tab and open the interactive Ruby console
+with `irb`. Then check the class of different numbers:
+
+`  1000.class`                      *# => Fixnum*
+`  4_611_686_018_427_387_904.class` *# => Bignum*
+
+If you want to learn more, read about Fixnum and Bignum here:
+- http://patshaughnessy.net/2014/1/9/how-big-is-a-bignum
+- (ruby-doc core: Integer)
+
+## Floats
+
+A *Float* represents an *inexact real number*.
+You can create a Float by declaring a number with a decimal place, like `3.0`
+or `-2_000.25`.
+Another way to create a Float is to call `Float()` with a parameter, e.g.:
+
+`  Float(3)`   *# => 3.0*
+`  Float('3')` *# => 3.0*
+
+Read more about Float here: (ruby-doc core: Float).
+
+## Rationals
+
+A *Rational* represents a rational number (a paired integer number a/b, where b > 0).
+You can create a Rational by calling `Rational()` with one or two parameters, e.g.:
+
+`  Rational(2)`     *# => (2/1)*
+`  Rational(2, 3)`  *# => (2/3)*
+`  Rarional('2/3')` *# => (2/3)*
+
+Read more about Rational here: (ruby-doc core: Rational).
+
+## Complex numbers
+
+A *Complex* represents a complex number.
+You can create a complex number by calling `Complex()` with one or two parameters, e.g.:
+
+`  Complex(2)`          *# => (2+0i)*
+`  Complex(2.1, 0.2)`   *# => (2.1+0.2i)*
+`  Complex('2.1+0.2i')` *# => (2.1+0.2i)*
+`  Complex('2.1@0.2')`  *# => (2.0581398134666076+0.4172055946696286i)* - polar form
+
+Read more about Complex here: (ruby-doc core: Complex).
+
+---
+
+Create a number of each described type and store it into a variable with the
+lowercased name of the number's class (e.g. *rational* for Rational).
+Create both types of Integers (*Fixnum* and *Bignum*)!
+
+---

2_Numbers/2_Basic_operators/solution.rb

@@ -0,0 +1,6 @@
+# e.g.:
+sum = Rational(1, 3) + Rational(2)
+difference = 1_000_000_000_000_000_000_000_000 - 1.9
+product = 2.4 * 5.6 * 2.3
+quotient = Complex(1) / 3.4
+power = Rational(2, 3) ** 3.5

2_Numbers/2_Basic_operators/solution_spec.rb

@@ -0,0 +1,64 @@
+require 'rspec'
+require 'rspec/expectations'
+require 'code_breaker'
+
+RSpec::Matchers.define :run_number_operations do |expected|
+  match do |actual|
+    CodeBreaker.parse(actual).include?(expected)
+  end
+
+  failure_message do |actual|
+    expected_operants = expected.values.first
+    variable_name = expected_operants[0]
+    expected_operation = "#{variable_name} = #{expected_operants[1].join(' ')}"
+
+    actual_line = actual.split("\n").select do |output|
+      output.match(/#{variable_name} =.+/)
+    end
+
+    actual_parsed = CodeBreaker.parse(actual_line.join)
+    actual_operants = actual_parsed.values.first
+    actual_operation = "#{variable_name} = #{actual_operants[1].join(' ')}"
+
+    %Q{Your code doesn't run the number operation "#{expected_operation}".
+      ------- Instead you calculated "#{actual_operation}".}
+  end
+end
+
+# code_breaker outputs
+OPERATIONS = [
+  { lvasgn: [:sum, [Rational, :+, Rational]] },
+  { lvasgn: [:difference, [Bignum, :-, Float]] },
+  { lvasgn: [:product, [Float, :*, Float, :*, Float]] },
+  { lvasgn: [:quotient, [Complex, :/, Float]] },
+  { lvasgn: [:power, [Rational, :**, Float]] }
+].freeze
+
+describe "Your code" do
+  [['solution::code']]
+
+  OPERATIONS.each do |operation|
+    variable_name = operation.first.last.first
+    values = operation.values.first.last
+
+    it "defines a variable with name \"#{variable_name}\"" do
+      expect(local_variables.include?(variable_name)).to be true
+    end
+
+    if local_variables.include?(variable_name)
+      operants  = values.select.each_with_index { |_, i| i.even? }
+      same_operants = (operants.uniq.count == 1)
+
+      numbers = if same_operants
+        "#{operants.count} #{values.first} numbers"
+      else
+        operants.join(' and a ')
+      end
+
+      it "calculates the #{variable_name} of #{numbers}" do
+        code_lines = %Q{ [['solution::code']] }
+        expect(code_lines).to run_number_operations(operation)
+      end
+    end
+  end
+end

2_Numbers/2_Basic_operators/task.md

@@ -0,0 +1,73 @@
+# Basic operators
+
+---
+
+*You will learn:*
+- how to use basic arithmetic operators on numbers
+- about the inaccuracy of *Float* values
+
+---
+
+All the numbers shown so far (*Fixnum*, *Bignum*, *Float*, *Rational*, and *Complex*)
+share the following basic operator methods:
+
+`  +`   (addition)
+`  -`   (subtraction)
+`  \*`   (multiplication)
+`  /`   (division)
+`  \*\*`  (exponentiation)
+
+You can apply these arithmetic operators by writing one of them between two
+numbers, e.g.:
+
+`  3.2 + 7`                              *# => 10.2*
+`  Rational(2, 3) - Rational(1, 2)`      *# => (1/6)*
+`  3 \* 5`                                *# => 15*
+`  Complex(2.0, 4) / Complex(4.0, 2.0)`  *# => (0.8+0.6000000000000001i)*
+`  2 \*\* 3`                               *# => 8*
+
+## "Strange" behaviours
+
+When you try some combinations of numbers and operators in the interactive Ruby
+console (irb), you might think that sometimes strange things are going on.
+
+For instance, why will `3 / 7` always equal *0*? And why does `0.6 + 0.3 + 0.1` equal
+*0.9999999999999999* and not *1.0*? (Try it, if you don't believe it!)
+
+The explanation can be found in how Ruby handles numbers.
+If you divide an *Integer* by another *Integer*, then the result will be the rounded
+down *Integer* value (`5 / 2` equals *2*, `7 / 2` equals *3*).
+To get a floating point number you have to use a *Float* for either the numerator
+or the denominator or for both of them, i.e.:
+
+`  3.0 / 7`   *# => 0.42857142857142855*
+`  3 / 7.0`   *# => 0.42857142857142855*
+`  3.0 / 7.0` *# => 0.42857142857142855*
+
+The inaccuracy when summing up *Floats* appears beacause a *Float* is an approximation
+of a decimal number. Since floating point numbers are stored in binary in your
+computer, small rounding errors are likely to occur.
+
+(if you really want to know what's going on here, you can read more about it on
+http://docs.sun.com/source/806-3568/ncg_goldberg.html!)
+
+This binary representation of *Floats* is also the explanation for the inaccuracy
+when calculating the division of two *Complex* numbers (as in the example above,
+where the imaginary part is *0.6000000000000001* instead of *0.6*).
+
+---
+
+Connect numbers by each of the learned operators:
+
+1. Sum up two *Rational* numbers
+2. Subtract a *Float* from a *Bignum*
+3. Build the product of three *Float* numbers
+4. Divide a *Complex* number by a *Fixnum*
+5. Calculate a *Rational* to the power of a *Float*
+
+Store each result in a variable that is named like the result of the operation, e.g.
+for 1. *sum*,
+for 2. *difference*,
+and so on.
+
+---

2_Numbers/3_Converting_numbers/solution.rb

@@ -0,0 +1,5 @@
+# e.g.:
+integer = Complex(2.5).to_i
+float = 42.to_f
+rational = 10.25.to_r
+complex = Rational(1.1, 3.3).to_c

2_Numbers/3_Converting_numbers/solution_spec.rb

@@ -0,0 +1,65 @@
+require 'rspec'
+require 'rspec/expectations'
+require 'code_breaker'
+
+RSpec::Matchers.define :run_number_conversions do |expected|
+  METHODS = {
+    to_i: 'to integer',
+    to_f: 'to float',
+    to_r: 'to Rational number',
+    to_c: 'to Complex number'
+  }
+
+  match do |actual|
+    CodeBreaker.parse(actual).include?(expected)
+  end
+
+  failure_message do |actual|
+    expected_operants = expected.values.first
+    variable_name = expected_operants[0]
+
+    expected_method = METHODS[expected_operants[1][1]]
+    expected_conversion = "#{variable_name} = #{expected_operants[1][0]} #{expected_method}"
+
+    actual_line = actual.split("\n").select do |output|
+      output.match(/#{variable_name} =.+/)
+    end
+
+    actual_parsed = CodeBreaker.parse(actual_line.join)
+    actual_operants = actual_parsed.values.first
+    actual_conversion = "#{variable_name} = #{[actual_operants[1]].flatten.join(' ')}"
+
+    %Q{Your code doesn't run the number conversion "#{expected_conversion}".
+      ------- Instead you defined "#{actual_conversion}".}
+  end
+end
+
+# code_breaker outputs
+CONVERSIONS = [
+  { lvasgn: [:integer, [Complex, :to_i]] },
+  { lvasgn: [:float, [Fixnum, :to_f]] },
+  { lvasgn: [:rational, [Float, :to_r]] },
+  { lvasgn: [:complex, [Rational, :to_c]] }
+].freeze
+
+describe "Your code" do
+  [['solution::code']]
+
+  CONVERSIONS.each do |conversion|
+    variable_name = conversion.first.last.first
+    values = conversion.values.first.last
+
+    it "defines a variable with name \"#{variable_name}\"" do
+      expect(local_variables.include?(variable_name)).to be true
+    end
+
+    if local_variables.include?(variable_name)
+      article = !!variable_name.match(/^[eioa]/) ? 'an' : 'a'
+
+      it "converts a #{values.first} number to #{article} #{variable_name}" do
+        code_lines = %Q{ [['solution::code']] }
+        expect(code_lines).to run_number_conversions(conversion)
+      end
+    end
+  end
+end

2_Numbers/3_Converting_numbers/task.md

@@ -0,0 +1,58 @@
+# Converting numbers
+
+---
+
+*You will learn:*
+- how to convert numbers to other number formats
+
+---
+
+There are several methods you can apply on numbers to explicitly convert a number
+to another number format:
+
+`  to_i` converts to an *Integer* number
+`  to_f` converts to a *Float* number
+`  to_r` converts to a *Rational* values
+`  to_c` converts to a *Complex* number
+
+Converting a number to its own type will just return the number, e.g.:
+
+`  123.to_i`                *# => 123*
+`  4.75.to_f`               *# => 4.75*
+`  Rational(3, 7).to_r`     *# => (3,7)*
+`  Complex(2.1, 3.2).to_c`  *# => (2.1+3.2i)*
+
+If you convert a Float, a Rational or a Complex number to an Integer by calling
+the `to_i` method then the digits after the decimal point are just cut off.
+Note that the size of the fraction doesn't matter:
+
+`  2.01.to_i` and `2.95.to_i` will both return *2*.
+
+If you want to convert a float to an integer based on its digits after the decimal point,
+you should have a look at the following methods of a Numeric:
+
+`  #ceils`: (ruby-doc core: Numeric#ceil)
+`  #floor`: (ruby-doc core: Numeric#floor)
+`  #round`: (ruby-doc core: Numeric#round)
+
+One thing you can't do is converting a Complex number with an imaginary part other
+than `0` to an integer, float, or rational number.
+
+For instance `Complex(5.3, 0.5).to_i` will throw an Error (*RangeError: can't convert 5.3+0.5i into Integer*),
+whereas `Complex(5.3).to_i` will give you a *5*.
+
+---
+
+Convert numbers into other formats:
+
+1. Convert a *Complex* number into an *Integer*
+2. Convert a *Fixnum* integer into a *Float*
+3. Convert a *Float* into a *Rational* number
+4. Convert a *Rational* number into an *Complex* number
+
+Store each result in a variable that is named like the resulting type of the conversion, e.g.
+for 1. *integer*,
+for 2. *float*,
+and so on.
+
+---