basic_temperature 0.2.1 → 0.2.2

data/docs/js/searcher.js

@@ -0,0 +1,229 @@
+Searcher = function(data) {
+  this.data = data;
+  this.handlers = [];
+}
+
+Searcher.prototype = new function() {
+  // search is performed in chunks of 1000 for non-blocking user input
+  var CHUNK_SIZE = 1000;
+  // do not try to find more than 100 results
+  var MAX_RESULTS = 100;
+  var huid = 1;
+  var suid = 1;
+  var runs = 0;
+
+  this.find = function(query) {
+    var queries = splitQuery(query);
+    var regexps = buildRegexps(queries);
+    var highlighters = buildHilighters(queries);
+    var state = { from: 0, pass: 0, limit: MAX_RESULTS, n: suid++};
+    var _this = this;
+
+    this.currentSuid = state.n;
+
+    if (!query) return;
+
+    var run = function() {
+      // stop current search thread if new search started
+      if (state.n != _this.currentSuid) return;
+
+      var results =
+        performSearch(_this.data, regexps, queries, highlighters, state);
+      var hasMore = (state.limit > 0 && state.pass < 4);
+
+      triggerResults.call(_this, results, !hasMore);
+      if (hasMore) {
+        setTimeout(run, 2);
+      }
+      runs++;
+    };
+    runs = 0;
+
+    // start search thread
+    run();
+  }
+
+  /*  ----- Events ------  */
+  this.ready = function(fn) {
+    fn.huid = huid;
+    this.handlers.push(fn);
+  }
+
+  /*  ----- Utilities ------  */
+  function splitQuery(query) {
+    return query.split(/(\s+|::?|\(\)?)/).filter(function(string) {
+      return string.match(/\S/);
+    });
+  }
+
+  function buildRegexps(queries) {
+    return queries.map(function(query) {
+      return new RegExp(query.replace(/(.)/g, '([$1])([^$1]*?)'), 'i');
+    });
+  }
+
+  function buildHilighters(queries) {
+    return queries.map(function(query) {
+      return query.split('').map(function(l, i) {
+        return '\u0001$' + (i*2+1) + '\u0002$' + (i*2+2);
+      }).join('');
+    });
+  }
+
+  // function longMatchRegexp(index, longIndex, regexps) {
+  //     for (var i = regexps.length - 1; i >= 0; i--){
+  //         if (!index.match(regexps[i]) && !longIndex.match(regexps[i])) return false;
+  //     };
+  //     return true;
+  // }
+
+
+  /*  ----- Mathchers ------  */
+
+  /*
+   * This record matches if the index starts with queries[0] and the record
+   * matches all of the regexps
+   */
+  function matchPassBeginning(index, longIndex, queries, regexps) {
+    if (index.indexOf(queries[0]) != 0) return false;
+    for (var i=1, l = regexps.length; i < l; i++) {
+      if (!index.match(regexps[i]) && !longIndex.match(regexps[i]))
+        return false;
+    };
+    return true;
+  }
+
+  /*
+   * This record matches if the longIndex starts with queries[0] and the
+   * longIndex matches all of the regexps
+   */
+  function matchPassLongIndex(index, longIndex, queries, regexps) {
+    if (longIndex.indexOf(queries[0]) != 0) return false;
+    for (var i=1, l = regexps.length; i < l; i++) {
+      if (!longIndex.match(regexps[i]))
+        return false;
+    };
+    return true;
+  }
+
+  /*
+   * This record matches if the index contains queries[0] and the record
+   * matches all of the regexps
+   */
+  function matchPassContains(index, longIndex, queries, regexps) {
+    if (index.indexOf(queries[0]) == -1) return false;
+    for (var i=1, l = regexps.length; i < l; i++) {
+      if (!index.match(regexps[i]) && !longIndex.match(regexps[i]))
+        return false;
+    };
+    return true;
+  }
+
+  /*
+   * This record matches if regexps[0] matches the index and the record
+   * matches all of the regexps
+   */
+  function matchPassRegexp(index, longIndex, queries, regexps) {
+    if (!index.match(regexps[0])) return false;
+    for (var i=1, l = regexps.length; i < l; i++) {
+      if (!index.match(regexps[i]) && !longIndex.match(regexps[i]))
+        return false;
+    };
+    return true;
+  }
+
+
+  /*  ----- Highlighters ------  */
+  function highlightRegexp(info, queries, regexps, highlighters) {
+    var result = createResult(info);
+    for (var i=0, l = regexps.length; i < l; i++) {
+      result.title = result.title.replace(regexps[i], highlighters[i]);
+      result.namespace = result.namespace.replace(regexps[i], highlighters[i]);
+    };
+    return result;
+  }
+
+  function hltSubstring(string, pos, length) {
+    return string.substring(0, pos) + '\u0001' + string.substring(pos, pos + length) + '\u0002' + string.substring(pos + length);
+  }
+
+  function highlightQuery(info, queries, regexps, highlighters) {
+    var result = createResult(info);
+    var pos = 0;
+    var lcTitle = result.title.toLowerCase();
+
+    pos = lcTitle.indexOf(queries[0]);
+    if (pos != -1) {
+      result.title = hltSubstring(result.title, pos, queries[0].length);
+    }
+
+    result.namespace = result.namespace.replace(regexps[0], highlighters[0]);
+    for (var i=1, l = regexps.length; i < l; i++) {
+      result.title = result.title.replace(regexps[i], highlighters[i]);
+      result.namespace = result.namespace.replace(regexps[i], highlighters[i]);
+    };
+    return result;
+  }
+
+  function createResult(info) {
+    var result = {};
+    result.title = info[0];
+    result.namespace = info[1];
+    result.path = info[2];
+    result.params = info[3];
+    result.snippet = info[4];
+    result.badge = info[6];
+    return result;
+  }
+
+  /*  ----- Searching ------  */
+  function performSearch(data, regexps, queries, highlighters, state) {
+    var searchIndex = data.searchIndex;
+    var longSearchIndex = data.longSearchIndex;
+    var info = data.info;
+    var result = [];
+    var i = state.from;
+    var l = searchIndex.length;
+    var togo = CHUNK_SIZE;
+    var matchFunc, hltFunc;
+
+    while (state.pass < 4 && state.limit > 0 && togo > 0) {
+      if (state.pass == 0) {
+        matchFunc = matchPassBeginning;
+        hltFunc = highlightQuery;
+      } else if (state.pass == 1) {
+        matchFunc = matchPassLongIndex;
+        hltFunc = highlightQuery;
+      } else if (state.pass == 2) {
+        matchFunc = matchPassContains;
+        hltFunc = highlightQuery;
+      } else if (state.pass == 3) {
+        matchFunc = matchPassRegexp;
+        hltFunc = highlightRegexp;
+      }
+
+      for (; togo > 0 && i < l && state.limit > 0; i++, togo--) {
+        if (info[i].n == state.n) continue;
+        if (matchFunc(searchIndex[i], longSearchIndex[i], queries, regexps)) {
+          info[i].n = state.n;
+          result.push(hltFunc(info[i], queries, regexps, highlighters));
+          state.limit--;
+        }
+      };
+      if (searchIndex.length <= i) {
+        state.pass++;
+        i = state.from = 0;
+      } else {
+        state.from = i;
+      }
+    }
+    return result;
+  }
+
+  function triggerResults(results, isLast) {
+    this.handlers.forEach(function(fn) {
+      fn.call(this, results, isLast)
+    });
+  }
+}
+

data/docs/panel/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>search index</title>
+  <link rel="stylesheet" href="../css/reset.css" type="text/css" media="screen" charset="utf-8" />
+  <link rel="stylesheet" href="../css/panel.css" type="text/css" media="screen" charset="utf-8" />
+  <script src="../js/search_index.js" type="text/javascript" charset="utf-8"></script>
+  <script src="../js/searcher.js" type="text/javascript" charset="utf-8"></script>
+  <script src="tree.js" type="text/javascript" charset="utf-8"></script>
+  <script src="../js/jquery-1.3.2.min.js" type="text/javascript" charset="utf-8"></script>
+  <script src="../js/searchdoc.js" type="text/javascript" charset="utf-8"></script>
+  <script type="text/javascript" charset="utf-8">
+  $(function() {
+    $('#links').hide();
+    var panel = new Searchdoc.Panel($('#panel'), search_data, tree, top.frames[1]);
+    $('#search').focus();
+
+    var s = window.parent.location.search.match(/\?q=([^&]+)/);
+    if (s) {
+      s = decodeURIComponent(s[1]).replace(/\+/g, ' ');
+      if (s.length > 0) {
+        $('#search').val(s);
+        panel.search(s, true);
+      }
+    }
+  })
+  </script>
+</head>
+
+<body>
+  <div class="panel panel_tree" id="panel">
+    <div class="header">
+      <input type="text" placeholder="Search for a class, method, ..." autosave="searchdoc" results="10" id="search" autocomplete="off" />
+    </div>
+    <div class="tree">
+      <ul>
+      </ul>
+    </div>
+    <div class="result">
+      <ul>
+      </ul>
+    </div>
+  </div>
+  <a href="links.html" id="links">index</a>
+</body>
+
+</html>

data/docs/panel/links.html

@@ -0,0 +1,12 @@
+<html>
+    <head>File index</head>
+    <body>
+    
+      <a href="../files/lib/basic_temperature_rb.html">lib/basic_temperature.rb</a>
+    
+      <a href="../files/lib/basic_temperature/temperature_rb.html">lib/basic_temperature/temperature.rb</a>
+    
+      <a href="../files/lib/basic_temperature/version_rb.html">lib/basic_temperature/version.rb</a>
+    
+    </body>
+</html>

data/docs/panel/tree.js

@@ -0,0 +1 @@
+var tree = [["","","files",[["","","lib",[["","","basic_temperature",[["temperature.rb","files/lib/basic_temperature/temperature_rb.html","",[]],["version.rb","files/lib/basic_temperature/version_rb.html","",[]]]],["basic_temperature.rb","files/lib/basic_temperature_rb.html","",[]]]]]],["Temperature","classes/BasicTemperature.html"," < Object",[]],["Object","classes/Object.html"," < BasicObject",[]],["Temperature","classes/Temperature.html"," < Object",[]]]

data/lib/basic_temperature.rb

@@ -2,28 +2,229 @@
 
 require 'basic_temperature/version'
 
-# Value Object for basic temperature operations like conversions from Celcius to Fahrenhait or Kelvin etc.
 # rubocop:disable Metrics/ClassLength
+
+##
+# Temperature is a simple {Value Object}[https://martinfowler.com/bliki/ValueObject.html] for basic
+# temperature operations like conversions from <tt>Celsius</tt> to <tt>Fahrenhait</tt> or <tt>Kelvin</tt>
+# etc.
+#
+# Supported scales: <tt>Celsius</tt>, <tt>Fahrenheit</tt>, <tt>Kelvin</tt> and <tt>Rankine</tt>.
+#
+# == Creating Temperatures
+#
+# A new temperature can be created in multiple ways:
+#
+# - Using keyword arguments:
+#
+#     Temperature.new(degrees: 0, scale: :celsius)
+#
+# - Using positional arguments:
+#
+#     Temperature.new(0, :celsius)
+#
+# - Even more concise way using <tt>Temperature.[]</tt> (an alias of <tt>Temperature.new</tt>):
+#
+#     Temperature[0, :celsius]
+#
+#
+# == Creating Temperatures from already existing temperature objects
+#
+# Sometimes it is useful to create a new temperature from already existing one.
+#
+# For such cases, there are {set_degrees}[rdoc-ref:BasicTemperature#set_degrees and
+# {set_scale}[rdoc-ref:BasicTemperature#set_scale].
+#
+# Since temperatures are {Value Objects}[https://martinfowler.com/bliki/ValueObject.html], both methods
+# returns new instances.
+#
+# Examples:
+#
+#   temperature = Temperature[0, :celsius]
+#   # => 0 °C
+#
+#   new_temperature = temperature.set_degrees(15)
+#   # => 15 °C
+#
+#   temperature = Temperature[0, :celsius]
+#   # => 0 °C
+#
+#   new_temperature = temperature.set_scale(:kelvin)
+#   # => 0 K
+#
+# == Conversions
+#
+# Temperatures can be converted to diffirent scales.
+#
+# Currently, the following scales are supported: <tt>Celsius</tt>, <tt>Fahrenheit</tt>, <tt>Kelvin</tt> and
+# <tt>Rankine</tt>.
+#
+#   Temperature[20, :celsius].to_celsius
+#   # => 20 °C
+#
+#   Temperature[20, :celsius].to_fahrenheit
+#   # => 68 °F
+#
+#   Temperature[20, :celsius].to_kelvin
+#   # => 293.15 K
+#
+#   Temperature[20, :celsius].to_rankine
+#   # => 527.67 °R
+#
+# If it is necessary to convert scale dynamically, {to_scale}[rdoc-ref:BasicTemperature#to_scale] method is
+# available.
+#
+#   Temperature[20, :celsius].to_scale(scale)
+#
+# All conversion formulas are taken from
+# {RapidTables}[https://www.rapidtables.com/convert/temperature/index.html].
+#
+# Conversion precision: 2 accurate digits after the decimal dot.
+#
+# == Comparison
+#
+# Temperature implements idiomatic {<=> spaceship operator}[https://ruby-doc.org/core/Comparable.html] and
+# mixes in {Comparable}[https://ruby-doc.org/core/Comparable.html] module.
+#
+# As a result, all methods from Comparable are available, e.g:
+#
+#   Temperature[20, :celsius] < Temperature[25, :celsius]
+#   # => true
+#
+#   Temperature[20, :celsius] <= Temperature[25, :celsius]
+#   # => true
+#
+#   Temperature[20, :celsius] == Temperature[25, :celsius]
+#   # => false
+#
+#   Temperature[20, :celsius] > Temperature[25, :celsius]
+#   # => false
+#
+#   Temperature[20, :celsius] >= Temperature[25, :celsius]
+#   # => false
+#
+#   Temperature[20, :celsius].between?(Temperature[15, :celsius], Temperature[25, :celsius])
+#   # => true
+#
+#   # Starting from Ruby 2.4.6
+#   Temperature[20, :celsius].clamp(Temperature[20, :celsius], Temperature[25, :celsius])
+#   # => 20 °C
+#
+# Please note, if <tt>other</tt> temperature has a different scale, temperature is automatically converted
+# to that scale before comparison.
+#
+#   Temperature[20, :celsius] == Temperature[293.15, :kelvin]
+#   # => true
+#
+# IMPORTANT !!!
+#
+# <tt>degrees</tt> are rounded to the nearest value with a precision of 2 decimal digits before comparison.
+#
+# This means the following temperatures are considered as equal:
+#
+#   Temperature[20.020, :celsius] == Temperature[20.024, :celsius]
+#   # => true
+#
+#   Temperature[20.025, :celsius] == Temperature[20.029, :celsius]
+#   # => true
+#
+# while these ones are treated as NOT equal:
+#
+#   Temperature[20.024, :celsius] == Temperature[20.029, :celsius]
+#   # => false
+#
+# == Math
+#
+# ==== Addition/Subtraction.
+#
+#   Temperature[20, :celsius] + Temperature[10, :celsius]
+#   # => 30 °C
+#
+#   Temperature[20, :celsius] - Temperature[10, :celsius]
+#   # => 10 °C
+#
+# If second temperature has a different scale, first temperature is automatically converted to that scale
+# before <tt>degrees</tt> addition/subtraction.
+#
+#   Temperature[283.15, :kelvin] + Temperature[10, :celsius]
+#   # => 10 °C
+#
+# Returned temperature will have the same scale as the second temperature.
+#
+# It is possible to add/subtract numerics.
+#
+#   Temperature[20, :celsius] + 10
+#   # => 30 °C
+#
+#   Temperature[20, :celsius] - 10
+#   # => 10 °C
+#
+# In such cases, returned temperature will have the same scale as the first temperature.
+#
+# Also {Ruby coersion mechanism}[https://ruby-doc.org/core/Numeric.html#method-i-coerce] is supported.
+#
+#   10 + Temperature[20, :celsius]
+#   # => 30 °C
+#
+#   10 - Temperature[20, :celsius]
+#   # => -10 °C
+#
+# ==== Negation
+#
+#   -Temperature[20, :celsius]
+#   # => -20 °C
+#
 class BasicTemperature
+  include Comparable
+
+  # Raised when <tt>Temperature.new</tt> is called with mixed positional and keyword arguments or without
+  # arguments at all.
   class InitializationArgumentsError < StandardError; end
+
+  # Raised when <tt>degrees</tt> is not a Numeric.
   class InvalidDegreesError < StandardError; end
+
+  # Raised when <tt>scale</tt> can not be casted to any possible scale value.
+  # See {SCALES}[rdoc-ref:BasicTemperature::SCALES].
   class InvalidScaleError < StandardError; end
-  class InvalidOtherError < StandardError; end
-  class CoersionError < StandardError; end
 
-  SCALES =
-    [
-      CELCIUS = 'celcius',
-      FAHRENHEIT = 'fahrenheit',
-      KELVIN = 'kelvin'
-    ]
-    .freeze
+  # Raised when <tt>other</tt> is not a Numeric or Temperature in math operations.
+  class InvalidNumericOrTemperatureError < StandardError; end
+
+  CELSIUS    = 'celsius'
+  FAHRENHEIT = 'fahrenheit'
+  KELVIN     = 'kelvin'
+  RANKINE    = 'rankine'
 
-  attr_reader :degrees, :scale
+  # A list of all currently supported scale values.
+  SCALES = [CELSIUS, FAHRENHEIT, KELVIN, RANKINE].freeze
+
+  # Degrees of the temperature.
+  attr_reader :degrees
+
+  # Scale of the temperature. Look at {SCALES}[rdoc-ref:BasicTemperature::SCALES] for possible values.
+  attr_reader :scale
+
+  ##
+  # Creates a new instance of Temperature. Alias for <tt>new</tt>.
+  #
+  # :call-seq:
+  #   [](degrees:, scale:)
+  #   [](degrees, scale)
+  #
+  def self.[](*args, **kwargs)
+    new(*args, **kwargs)
+  end
 
+  ##
+  # Creates a new instance of Temperature. Is aliased as <tt>[]</tt>.
+  #
+  # :call-seq:
+  #   new(degrees:, scale:)
+  #   new(degrees, scale)
+  #
   def initialize(*positional_arguments, **keyword_arguments)
-    raise_initialization_arguments_error if positional_arguments.any? && keyword_arguments.any?
-    raise_initialization_arguments_error if positional_arguments.none? && keyword_arguments.none?
+    assert_either_positional_arguments_or_keyword_arguments!(positional_arguments, keyword_arguments)
 
     if keyword_arguments.any?
       initialize_via_keywords_arguments(keyword_arguments)
@@ -33,124 +234,352 @@ class BasicTemperature
   end
 
   # rubocop:disable Naming/AccessorMethodName
+
+  # Returns a new Temperature with updated <tt>degrees</tt>.
+  #
+  #   temperature = Temperature[0, :celsius]
+  #   # => 0 °C
+  #
+  #   new_temperature = temperature.set_degrees(15)
+  #   # => 15 °C
+  #
   def set_degrees(degrees)
     BasicTemperature.new(degrees, scale)
   end
   # rubocop:enable Naming/AccessorMethodName
 
   # rubocop:disable Naming/AccessorMethodName
+
+  # Returns a new Temperature with updated <tt>scale</tt>.
+  #
+  #   temperature = Temperature[0, :celsius]
+  #   # => 0 °C
+  #
+  #   new_temperature = temperature.set_scale(:kelvin)
+  #   # => 0 K
+  #
   def set_scale(scale)
-    self.to_scale(scale)
+    BasicTemperature.new(degrees, scale)
   end
   # rubocop:enable Naming/AccessorMethodName
 
+  ##
+  # Converts temperature to specific <tt>scale</tt>.
+  # If temperature is already in desired <tt>scale</tt>, returns current temperature object.
+  #
+  # Raises {InvalidScaleError}[rdoc-ref:BasicTemperature::InvalidScaleError]
+  # when <tt>scale</tt> can not be casted to any possible scale value
+  # (see {SCALES}[rdoc-ref:BasicTemperature::SCALES]).
+  #
+  #   Temperature[60, :fahrenheit].to_scale(:celsius)
+  #   # => 15.56 °C
+  #
   def to_scale(scale)
-    case cast_scale(scale)
-    when CELCIUS
+    casted_scale = cast_scale(scale)
+
+    assert_valid_scale!(casted_scale)
+
+    case casted_scale
+    when CELSIUS
       to_celsius
     when FAHRENHEIT
       to_fahrenheit
     when KELVIN
       to_kelvin
-    else
-      raise_invalid_scale_error
+    when RANKINE
+      to_rankine
     end
   end
 
+  ##
+  # Converts temperature to Celsius scale. If temperature is already in Celsius, returns current
+  # temperature object.
+  #
+  # Memoizes subsequent calls.
+  #
+  # Conversion formulas are taken from {RapidTables}[https://www.rapidtables.com/]:
+  # 1. {Celsius to Fahrenheit}[https://www.rapidtables.com/convert/temperature/celsius-to-fahrenheit.html].
+  # 2. {Celsius to Kelvin}[https://www.rapidtables.com/convert/temperature/celsius-to-kelvin.html].
+  # 3. {Celsius to Rankine}[https://www.rapidtables.com/convert/temperature/celsius-to-rankine.html].
+  #
+  #   Temperature[0, :fahrenheit].to_celsius
+  #   # => -17.78 °C
+  #
   def to_celsius
-    return @to_celsius unless @to_celsius.nil?
-
-    return @to_celsius = self if self.scale == CELCIUS
-
-    degrees =
-      case self.scale
-      when FAHRENHEIT
-        (self.degrees - 32) * (5 / 9r)
-      when KELVIN
-        self.degrees - 273.15
-      end
-
-    @to_celsius = BasicTemperature.new(degrees, CELCIUS)
+    memoized(:to_celsius) || memoize(:to_celsius, -> {
+      return self if self.scale == CELSIUS
+
+      degrees =
+        case self.scale
+        when FAHRENHEIT
+          (self.degrees - 32) * (5 / 9r)
+        when KELVIN
+          self.degrees - 273.15
+        when RANKINE
+          (self.degrees - 491.67) * (5 / 9r)
+        end
+
+      BasicTemperature.new(degrees, CELSIUS)
+    })
   end
 
+  ##
+  # Converts temperature to Fahrenheit scale. If temperature is already in Fahrenheit, returns current
+  # temperature object.
+  #
+  # Memoizes subsequent calls.
+  #
+  # Conversion formulas are taken from {RapidTables}[https://www.rapidtables.com/]:
+  # 1. {Fahrenheit to Celsius}[https://www.rapidtables.com/convert/temperature/fahrenheit-to-celsius.html].
+  # 2. {Fahrenheit to Kelvin}[https://www.rapidtables.com/convert/temperature/fahrenheit-to-kelvin.html].
+  # 3. {Fahrenheit to Rankine}[https://www.rapidtables.com/convert/temperature/fahrenheit-to-rankine.html].
+  #
+  #   Temperature[0, :celsius].to_fahrenheit
+  #   # => 32 °F
+  #
   def to_fahrenheit
-    return @to_fahrenheit unless @to_fahrenheit.nil?
-
-    return @to_fahrenheit = self if self.scale == FAHRENHEIT
-
-    degrees =
-      case self.scale
-      when CELCIUS
-        self.degrees * (9 / 5r) + 32
-      when KELVIN
-        self.degrees * (9 / 5r) - 459.67
-      end
-
-    @to_fahrenheit = BasicTemperature.new(degrees, FAHRENHEIT)
+    memoized(:to_fahrenheit) || memoize(:to_fahrenheit, -> {
+      return self if self.scale == FAHRENHEIT
+
+      degrees =
+        case self.scale
+        when CELSIUS
+          self.degrees * (9 / 5r) + 32
+        when KELVIN
+          self.degrees * (9 / 5r) - 459.67
+        when RANKINE
+          self.degrees - 459.67
+        end
+
+      BasicTemperature.new(degrees, FAHRENHEIT)
+    })
   end
 
+  ##
+  # Converts temperature to Kelvin scale. If temperature is already in Kelvin, returns current
+  #  temperature object.
+  #
+  # Memoizes subsequent calls.
+  #
+  # Conversion formulas are taken from {RapidTables}[https://www.rapidtables.com/]:
+  # 1. {Kelvin to Celsius}[https://www.rapidtables.com/convert/temperature/kelvin-to-celsius.html].
+  # 2. {Kelvin to Fahrenheit}[https://www.rapidtables.com/convert/temperature/kelvin-to-fahrenheit.html].
+  # 3. {Kelvin to Rankine}[https://www.rapidtables.com/convert/temperature/kelvin-to-rankine.html].
+  #
+  #   Temperature[0, :kelvin].to_rankine
+  #   # => 0 °R
+  #
   def to_kelvin
-    return @to_kelvin unless @to_kelvin.nil?
-
-    return @to_kelvin = self if self.scale == KELVIN
-
-    degrees =
-      case self.scale
-      when CELCIUS
-        self.degrees + 273.15
-      when FAHRENHEIT
-        (self.degrees + 459.67) * (5 / 9r)
-      end
+    memoized(:to_kelvin) || memoize(:to_kelvin, -> {
+      return self if self.scale == KELVIN
+
+      degrees =
+        case self.scale
+        when CELSIUS
+          self.degrees + 273.15
+        when FAHRENHEIT
+          (self.degrees + 459.67) * (5 / 9r)
+        when RANKINE
+          self.degrees * (5 / 9r)
+        end
+
+      BasicTemperature.new(degrees, KELVIN)
+    })
+  end
 
-    @to_kelvin = BasicTemperature.new(degrees, KELVIN)
+  ##
+  # Converts temperature to Rankine scale. If temperature is already in Rankine, returns current
+  # temperature object.
+  #
+  # Memoizes subsequent calls.
+  #
+  # Conversion formulas are taken from {RapidTables}[https://www.rapidtables.com/]:
+  # 1. {Rankine to Celsius}[https://www.rapidtables.com/convert/temperature/rankine-to-celsius.html].
+  # 2. {Rankine to Fahrenheit}[https://www.rapidtables.com/convert/temperature/rankine-to-fahrenheit.html].
+  # 3. {Rankine to Kelvin}[https://www.rapidtables.com/convert/temperature/rankine-to-kelvin.html].
+  #
+  #   Temperature[0, :rankine].to_kelvin
+  #   # => 0 K
+  #
+  def to_rankine
+    memoized(:to_rankine) || memoize(:to_rankine, -> {
+      return self if self.scale == RANKINE
+
+      degrees =
+        case self.scale
+        when CELSIUS
+          (self.degrees + 273.15) * (9 / 5r)
+        when FAHRENHEIT
+          self.degrees + 459.67
+        when KELVIN
+          self.degrees * (9 / 5r)
+        end
+
+      BasicTemperature.new(degrees, RANKINE)
+    })
   end
 
-  def ==(other)
-    return false unless other.instance_of?(BasicTemperature)
+  ##
+  # Compares temperture with <tt>other</tt> temperature.
+  #
+  # Returns <tt>0</tt> if they are considered as equal.
+  #
+  # Two temperatures are considered as equal when they have the same amount of <tt>degrees</tt>.
+  #
+  # Returns <tt>-1</tt> if temperature is lower than <tt>other</tt> temperature.
+  #
+  # Returns <tt>1</tt> if temperature is higher than <tt>other</tt> temperature.
+  #
+  # If <tt>other</tt> temperature has a different scale, temperature is automatically converted to that scale
+  # before <tt>degrees</tt> comparison.
+  #
+  #   Temperature[20, :celsius] <=> Temperature[20, :celsius]
+  #   # => 0
+  #
+  #   Temperature[20, :celsius] <=> Temperature[293.15, :kelvin]
+  #   # => 0
+  #
+  # IMPORTANT!!!
+  #
+  # This method rounds <tt>degrees</tt> to the nearest value with a precision of 2 decimal digits.
+  #
+  # This means the following:
+  #
+  #   Temperature[20.020, :celsius] <=> Temperature[20.024, :celsius]
+  #   # => 0
+  #
+  #   Temperature[20.025, :celsius] <=> Temperature[20.029, :celsius]
+  #   # => 0
+  #
+  #   Temperature[20.024, :celsius] <=> Temperature[20.029, :celsius]
+  #   # => -1
+  #
+  def <=>(other)
+    return unless assert_temperature(other)
 
-    self.degrees == other.degrees && self.scale == other.scale
+    compare_degrees(self.to_scale(other.scale).degrees, other.degrees)
   end
 
+  ##
+  # Performs addition. Returns a new Temperature.
+  #
+  #   Temperature[20, :celsius] + Temperature[10, :celsius]
+  #   # => 30 °C
+  #
+  # If the second temperature has a different scale, the first temperature is automatically converted to that
+  # scale before <tt>degrees</tt> addition.
+  #
+  #   Temperature[283.15, :kelvin] + Temperature[20, :celsius]
+  #   # => 30 °C
+  #
+  # Returned temperature will have the same scale as the second temperature.
+  #
+  # It is possible to add numerics.
+  #
+  #   Temperature[20, :celsius] + 10
+  #   # => 30 °C
+  #
+  # In such cases, returned temperature will have the same scale as the first temperature.
+  #
+  # Also {Ruby coersion mechanism}[https://ruby-doc.org/core/Numeric.html#method-i-coerce] is supported.
+  #
+  #   10 + Temperature[20, :celsius]
+  #   # => 30 °C
+  #
+  # :call-seq:
+  #   +(temperature)
+  #   +(numeric)
+  #
   def +(other)
+    assert_numeric_or_temperature!(other)
+
     degrees, scale =
       case other
       when Numeric
         [self.degrees + other, self.scale]
       when BasicTemperature
         [self.to_scale(other.scale).degrees + other.degrees, other.scale]
-      else
-        raise_invalid_other_error(other)
       end
 
     BasicTemperature.new(degrees, scale)
   end
 
+  ##
+  # Performs subtraction. Returns a new Temperature.
+  #
+  #   Temperature[20, :celsius] - Temperature[10, :celsius]
+  #   # => 10 °C
+  #
+  # If the second temperature has a different scale, the first temperature is automatically converted to that
+  # scale before <tt>degrees</tt> subtraction.
+  #
+  #   Temperature[283.15, :kelvin] + Temperature[10, :celsius]
+  #   # => 10 °C
+  #
+  # Returned temperature will have the same scale as the second temperature.
+  #
+  # It is possible to subtract numerics.
+  #
+  #   Temperature[20, :celsius] - 10
+  #   # => 10 °C
+  #
+  # In such cases, returned temperature will have the same scale as the first temperature.
+  #
+  # Also {Ruby coersion mechanism}[https://ruby-doc.org/core/Numeric.html#method-i-coerce] is supported.
+  #
+  #   10 - Temperature[20, :celsius]
+  #   # => -10 °C
+  #
+  # :call-seq:
+  #   -(temperature)
+  #   -(numeric)
+  #
   def -(other)
     self + -other
   end
 
+  ##
+  # Returns a new Temperature with negated <tt>degrees</tt>.
+  #
+  #   -Temperature[20, :celsius]
+  #   # => -20 °C
+  #
   def -@
     BasicTemperature.new(-self.degrees, self.scale)
   end
 
-  def coerce(numeric)
+  # Is used by {+}[rdoc-ref:BasicTemperature#+] and {-}[rdoc-ref:BasicTemperature#-]
+  # for {Ruby coersion mechanism}[https://ruby-doc.org/core/Numeric.html#method-i-coerce].
+  def coerce(numeric) #:nodoc:
     assert_numeric!(numeric)
 
     [BasicTemperature.new(numeric, self.scale), self]
   end
 
-  def inspect
-    "#{degrees.to_i} #{scale.capitalize}"
-  end
+  # Returns a string containing a human-readable representation of temperature.
+  def inspect #:nodoc:
+    rounded_degrees = round_degrees(degrees)
 
-  def <=>(other)
-    return unless other.instance_of?(BasicTemperature)
+    printable_degrees = degrees_without_decimal?(rounded_degrees) ? rounded_degrees.to_i : rounded_degrees
 
-    self.to_scale(other.scale).degrees <=> other.degrees
+    scale_symbol =
+      case self.scale
+      when CELSIUS
+        '°C'
+      when FAHRENHEIT
+        '°F'
+      when KELVIN
+        'K'
+      when RANKINE
+        '°R'
+      end
+
+    "#{printable_degrees} #{scale_symbol}"
   end
 
   private
 
+  # Initialization
   def initialize_via_positional_arguments(positional_arguments)
     degrees, scale = positional_arguments
 
@@ -164,19 +593,31 @@ class BasicTemperature
   end
 
   def initialize_arguments(degrees, scale)
+    casted_degrees = cast_degrees(degrees)
     casted_scale = cast_scale(scale)
 
-    assert_valid_degrees!(degrees)
+    assert_valid_degrees!(casted_degrees)
     assert_valid_scale!(casted_scale)
 
-    @degrees = degrees
+    @degrees = casted_degrees
     @scale = casted_scale
   end
 
+  # Casting
+  def cast_degrees(degrees)
+    Float(degrees) rescue nil
+  end
+
   def cast_scale(scale)
     scale.to_s
   end
 
+  # Assertions
+  def assert_either_positional_arguments_or_keyword_arguments!(positional_arguments, keyword_arguments)
+    raise_initialization_arguments_error if positional_arguments.any? && keyword_arguments.any?
+    raise_initialization_arguments_error if positional_arguments.none? && keyword_arguments.none?
+  end
+
   def assert_valid_degrees!(degrees)
     raise_invalid_degrees_error unless degrees.is_a?(Numeric)
   end
@@ -188,13 +629,18 @@ class BasicTemperature
   def assert_numeric_or_temperature!(numeric_or_temperature)
     return if numeric_or_temperature.is_a?(Numeric) || numeric_or_temperature.instance_of?(BasicTemperature)
 
-    raise_coersion_error(numeric_or_temperature)
+    raise_invalid_numeric_or_temperature_error(numeric_or_temperature)
   end
 
   def assert_numeric!(numeric)
     raise_invalid_numeric unless numeric.is_a?(Numeric)
   end
 
+  def assert_temperature(temperature)
+    temperature.instance_of?(BasicTemperature)
+  end
+
+  # Raising errors
   def raise_initialization_arguments_error
     message =
       'Positional and keyword arguments are mixed or ' \
@@ -215,12 +661,43 @@ class BasicTemperature
     raise InvalidScaleError, message
   end
 
-  def raise_invalid_other_error(other)
-    raise InvalidOtherError, "`#{other}` is neither Numeric nor Temperature."
+  def raise_invalid_numeric_or_temperature_error(numeric_or_temperature)
+    raise InvalidNumericOrTemperatureError, "`#{numeric_or_temperature}` is neither Numeric nor Temperature."
+  end
+
+  # Rounding
+  def round_degrees(degrees)
+    degrees.round(2)
+  end
+
+  def compare_degrees(first_degrees, second_degrees)
+    round_degrees(first_degrees) <=> round_degrees(second_degrees)
+  end
+
+  def degrees_with_decimal?(degrees)
+    degrees % 1 != 0
+  end
+
+  def degrees_without_decimal?(degrees)
+    !degrees_with_decimal?(degrees)
+  end
+
+  # Memoization
+  def memoized(key)
+    name = convert_to_variable_name(key)
+
+    instance_variable_get(name) if instance_variable_defined?(name)
+  end
+
+  def memoize(key, proc)
+    name = convert_to_variable_name(key)
+    value = proc.call
+
+    instance_variable_set(name, value)
   end
 
-  def raise_coersion_error(object)
-    raise CoersionError, "#{object} is neither Numeric nor Temperature."
+  def convert_to_variable_name(key)
+    "@#{key}"
   end
 end
 # rubocop:enable Metrics/ClassLength