fraction-tree 1.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d4c2e3c84acc2fa31151b2863bf7c602490e891004198884e8002a7b7f3cc32
-  data.tar.gz: c335d6bfb3f54c8471835cbc9283d904f8d71f7786cfde02a41448a1840ecb02
+  metadata.gz: 6a5099eb066c0e5fae9c4553a44b75ca90b52db8c4711b7d7a07247d116e93ea
+  data.tar.gz: 20624486f4b7987331ce3abc1f724a183212d3d403ab207d71a7bdbcf081c3a7
 SHA512:
-  metadata.gz: ef4347b24418118dbf6f4c8fdc6ac03829829aaf5c15d51295befda2f6bddad1b7022b7b428906998ab2a18106a68850dacdc61c3616a345d911f5db32008c86
-  data.tar.gz: 940a05ae9a163d32cae321457da5135334f8a45a96bd0a6141d420d133216c912cd50826c33c3488fa7c17c96286ec11e755e2c8199afe4cddc8fee9846e25bf
+  metadata.gz: a9abac107904f305c8a23fd34a4fb838b35ddca05046c7713a1c823c82848b85b914c055b2c1a24b3e2b440cfc04d23ad95fd312df4351d7244cfad0c5850a61
+  data.tar.gz: bfac6032e8f9b958e3f766bb16e7160a5ddb56fe2234e6fc79df6fe4317eb823cdcbb374508d1fbd3172b27334a7921a1c0f0c33b82e07ec767c8fc98c116952

data/lib/fraction_tree/extensions.rb

@@ -0,0 +1,29 @@
+class String
+  # @return [FractionTree::Node] string Stern-Brocot decoded
+  # @example
+  #   "1/0".to_node => (1/0)
+  #
+  def to_node
+    if self.include?(".")
+      number = self.to_d
+      numerator, denominator = number.numerator, number.denominator
+    elsif self.include?("/")
+      (numerator, denominator) = self.split("/").map(&:to_i)
+    else
+      number = self.to_r
+      numerator, denominator = number.numerator, number.denominator
+    end
+    number = denominator.zero? ? Float::INFINITY : Rational(numerator, denominator)
+    FractionTree::Node.new(number)
+  end
+end
+
+class Numeric
+  # @return [FractionTree::Node] string Stern-Brocot decoded
+  # @example
+  #   Float::INFINITY.to_node => (1/0)
+  #
+  def to_node
+    FractionTree.node(self)
+  end
+end

data/lib/fraction_tree/fraction_tree.rb

@@ -0,0 +1,256 @@
+# @author Jose Hales-Garcia
+#
+class FractionTree
+  DEFAULT_TREE_DEPTH = 20
+
+  private_class_method :new
+
+  class << self
+    # @return the left-most node of the range of the tree
+    # @example
+    #   FractionTree.left_node => 0/1
+    # @note defaults to Stern-Brocot left-most range, 0
+    #
+    def left_node
+      @left_node || 0/1r
+    end
+
+    # @return the right-most node of the range of the tree
+    # @example
+    #   FractionTree.right_node => Infinity
+    # @note defaults to Stern-Brocot right-most range, Infinity
+    #
+    def right_node
+      @right_node || Float::INFINITY
+    end
+
+    # Set the left-most node of the range of the tree
+    # @example
+    #   FractionTree.left_node = 1/1r
+    #
+    def left_node=(rhs)
+      @left_node = rhs
+    end
+
+    # Set the right-most node of the range of the tree
+    # @example
+    #   FractionTree.right_node = 2/1r
+    #
+    def right_node=(rhs)
+      @right_node = rhs
+    end
+
+    # @return the range of the tree
+    # @example
+    #   FractionTree.range => (0/1..Infinity)
+    # @note defaults to Stern-Brocot range, (0..Infinity)
+    #
+    def range
+      (left_node..right_node)
+    end
+
+    # Set the range of the tree
+    # @example
+    #   FractionTree.range = :farey
+    #   => (0/1..1/1)
+    # @note Accepts keywords:
+    #   :farey, :keyboard, :scale_step, :log2 => (0/1..1/1)
+    #   :stern_brocot, :scale => (0/1..1/0)
+    #   :octave_reduced => (1/1..2/1)
+    #
+    def range=(rhs)
+      case rhs
+      when :farey, :keyboard, :scale_step, :log2
+        @left_node, @right_node = 0/1r, 1/1r
+      when :stern_brocot, :scale
+        @left_node, @right_node = 0/1r, Float::INFINITY
+      when :octave_reduced
+        @left_node, @right_node = 1/1r, 2/1r
+      else
+        @left_node = @right_node = nil
+      end
+    end
+
+    # The cache of nodes used for faster lookup
+    # @note Intended for internal use.
+    def nodes
+      @@nodes ||= {}
+    end
+
+    # Reset the cache of nodes
+    # @example
+    #   FractionTree.reset_nodes => {}
+    #
+    def reset_nodes
+      @@nodes = {}
+    end
+
+    # @return [FractionTree::Node] the node in the tree representing the given number
+    # @example
+    #   FractionTree.node(3/2r) => (3/2)
+    #
+    def node(number)
+      validate(number)
+      nodes[number] ||= Node.new(number)
+    end
+
+    # @return [FractionTree::Node] the node decoded from the given string
+    # @example
+    #   FractionTree.decode("RLL") => (4/3)
+    #
+    def decode(str)
+      wrk_node = Node.decode(str)
+      nodes[wrk_node.number] ||= wrk_node
+    end
+
+    # @return [FractionTree::Node] the mediant sum of the given numbers
+    # @example
+    #   FractionTree.mediant_sum(3/2r, 4/3r) => (7/5)
+    #
+    def mediant_sum(n1, n2)
+      Node.new(n1) + Node.new(n2)
+    end
+
+    # @return [Boolean] whether two numbers are neighbors
+    # @example
+    #   FractionTree.neighbors?(3/2r, 4/3r) => true
+    #   FractionTree.neighbors?(3/2r, 7/4r) => false
+    #   FractionTree.neighbors?(2/1r, Float::INFINITY) => true
+    # @param number1 of comparison
+    # @param number2 of comparison
+    # @note Neighbor definition: abs(a * d - b * c) = 1, for a/b, c/d
+    # @note Float::INFINITY => 1/0
+    #
+    def neighbors?(number1, number2)
+      (a, b) = number1.infinite? ? [1, 0] : [number1.numerator, number1.denominator]
+      (c, d) = number2.infinite? ? [1, 0] : [number2.numerator, number2.denominator]
+      (a * d - b * c).abs == 1
+    end
+
+    # @return [Array] a multi-dimensional array of fraction tree nodes
+    # @example
+    #   FractionTree.tree(depth: 4)
+    #   => [[(0/1), (1/0)],
+    #       [(1/1)],
+    #       [(1/2), (2/1)],
+    #       [(1/3), (2/3), (3/2), (3/1)]]
+    #
+    # @param depth [Integer] the depth of the tree
+    # @param left_node [FractionTree::Node] the left starting node
+    # @param right_node [FractionTree::Node] the right starting node
+    #
+    def tree(depth: 10, left_node: default_left_node, right_node: default_right_node)
+      Array.new(depth, 0).tap do |sbt|
+        row = 0
+        sbt[row] = [left_node, right_node]
+        i = 2
+        while i <= depth do
+          figure_from = sbt[0..row].flatten.sort
+          new_frow = Array.new(2**(i-2), 0)
+          idx = 0
+          figure_from.each_cons(2) do |left, right|
+            new_frow[idx] = left + right
+            idx += 1
+          end
+          row += 1
+          sbt[row] = new_frow
+          i += 1
+        end
+      end
+    end
+
+    # @return [FractionTree::Node] the mediant child of the given numbers
+    # @example
+    #   FractionTree.child_of(1/1r, 4/3r) => (5/4)
+    #   FractionTree.child_of(7/4r, 4/3r) => nil
+    #
+    # @param number1 [Rational] one of two parents
+    # @param number2 [Rational] two of two parents
+    # @note return nil if bc - ad |= 1, for a/b, c/d
+    #
+    def child_of(number1, number2)
+      return nil unless neighbors?(number1, number2)
+      # node(number1.numerator, number1.denominator) + node(number2.numerator, number2.denominator)
+      node(number1) + node(number2)
+    end
+
+    # @return [Array] of fraction tree nodes descended from parent1 and parent2
+    #   Return empty array if bc - ad |= 1, for a/b, c/d
+    # @example
+    #   FractionTree.descendants_of(1/1r, 4/3r)
+    #   => [(1/1), (7/6), (6/5), (11/9), (5/4), (14/11), (9/7), (13/10), (4/3)]
+    #
+    # @param parent1 [Rational] one of two parents
+    # @param parent2 [Rational] two of two parents
+    # @param depth [Integer] the depth to collect
+    #
+    def descendants_of(parent1, parent2, depth: 5)
+      return [] unless neighbors?(parent1, parent2)
+      sequence(depth:, left_node: Node.new(parent1), right_node: Node.new(parent2))
+    end
+
+    # @return [Array] a sequence of fraction tree nodes
+    # @example
+    #   FractionTree.new.sequence(3)
+    #     => [(0/1), (1/3), (1/2), (2/3), (1/1), (3/2), (2/1), (3/1), (1/0)]
+    #
+    # @param depth [Integer] the number of iterations of the algorithm to run. The number of nodes returned will be greater
+    # @param left_node [FractionTree::Node] the left starting node
+    # @param right_node [FractionTree::Node] the right starting node 
+    #
+    def sequence(depth: 5, left_node: default_left_node, right_node: default_right_node)
+      [left_node]+_sequence(depth:, left_node:, right_node:)+[right_node]
+    end
+
+    # @return [Array] of numerators of the fraction tree nodes. Aka the Stern-Brocot sequence.
+    # @example
+    #   FractionTree.numeric_sequence.take(12)
+    #   => [1, 1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2]
+    #
+    def numeric_sequence
+      return enum_for :numeric_sequence unless block_given?
+      a=[1,1]
+
+      0.step do |i|
+        yield a[i]
+        a << a[i]+a[i+1] << a[i+1]
+      end
+    end
+
+    private
+    def validate(num)
+      raise(ArgumentError, "#{num} not in range of #{range}", caller[0]) unless range.include?(num)
+    end
+
+    def default_left_node
+      node(left_node)
+    end
+
+    def default_right_node
+      node(right_node)
+    end
+
+    def _node(num, den=nil)
+      if num.kind_of?(Float)
+        num = num.to_d
+      end
+      if num.infinite?
+        num, den = 1, 0
+      end
+      if den.nil?
+        den = num.denominator
+        num = num.numerator
+      end
+      Node.new(num, den)
+    end
+
+    def _sequence(depth: 5, left_node:, right_node:)
+      return [] if depth == 0
+
+      mediant = left_node + right_node
+
+      # Generate left segment, mediant, then right segment
+      _sequence(depth: depth - 1, left_node:, right_node: mediant) + [mediant] + _sequence(depth: depth - 1, left_node: mediant, right_node:)
+    end
+  end
+end

data/lib/fraction_tree/node.rb

@@ -0,0 +1,252 @@
+# @author Jose Hales-Garcia
+#
+class FractionTree
+  class Node
+    extend Forwardable
+    include Comparable
+
+    def_delegators :@number, :zero?, :infinite?
+
+    attr_reader :numerator, :denominator, :number
+
+    IDENTITY_MATRIX = Matrix.identity(2)
+    LEFT_MATRIX = Matrix[[1,1],[0,1]]
+    RIGHT_MATRIX = Matrix[[1,0],[1,1]]
+
+    def initialize(num)
+      (@numerator, @denominator) = fraction_pair(num)
+      @number = num
+    end
+
+    alias :to_r :number
+
+    class << self
+      # @return [FractionTree::Node] the fraction decoded from the given string
+      # @example
+      #   FractionTree::Node.decode("RLL") => (4/3)
+      #
+      def decode(string)
+        result = IDENTITY_MATRIX
+
+        string.split("").each do |direction|
+          case direction
+          when "L", "0", "l"
+            result = result * LEFT_MATRIX
+          when "R", "1", "r"
+            result = result * RIGHT_MATRIX
+          end
+        end
+        FractionTree.node(Rational(result.row(1).sum, result.row(0).sum))
+      end
+
+      # @return [String] the Stern-Brocot encoding of number
+      # @example
+      #   FractionTree::Node.encode(4/3r) => "RLL"
+      # @param limit of codes to generate
+      #
+      def encode(number, limit: Float::INFINITY)
+        return nil if (number.infinite? || number.zero?)
+
+        m = number.numerator
+        n = number.denominator
+
+        return "I" if m == n
+
+        "".tap do |string|
+          while m != n && string.length < limit
+            if m < n
+              string << "L"
+              n = n - m
+            else
+              string << "R"
+              m = m - n
+            end
+          end
+        end
+      end
+
+      # @return [Array] pair of numbers less and greater than the provided number by provided difference
+      # @example
+      #   FractionTree::Node.plus_minus(3, 2) => [1, 5]
+      # @param
+      #   num the base
+      #   diff the number subtracted and added to base
+      #
+      def plus_minus(num, diff)
+        [num - diff, num + diff]
+      end
+
+      # @return [Integer] the decimal power of the provided number
+      # @example
+      #   FractionTree::Node.decimal_power(1000) => 3
+      # @param
+      #   logarithmand the number from which the log base 10 is obtained
+      #
+      def decimal_power(logarithmand)
+        Math.log10(logarithmand.abs).floor
+      end
+    end
+
+    # @return [Array] set of fraction tree nodes leading to the given number
+    # @example
+    #    FractionTree.node(7/4r).path
+    #    => [(0/1), (1/0), (1/1), (2/1), (3/2), (5/3), (7/4)]
+    # @param limit of nodes to generate
+    #
+    def path(limit: Float::INFINITY)
+      return nil if infinite? || zero?
+
+      ln = tree.node(FractionTree.left_node)
+      rn = tree.node(FractionTree.right_node)
+      mn = ln + rn
+      return [ln, rn, mn] if mn == tree.node(number)
+
+      result = IDENTITY_MATRIX
+      m = numerator
+      n = denominator
+      [].tap do |p|
+        p << ln << rn << mn
+        while m != n && p.length < limit
+          if m < n
+            result = result * LEFT_MATRIX
+            n = n - m
+          else
+            result = result * RIGHT_MATRIX
+            m = m - n
+          end
+          p << tree.node(Rational(result.row(1).sum,result.row(0).sum))
+        end
+      end
+    end
+
+    # @return [Array] a pair of fraction tree nodes leading to the given number.
+    # @example
+    #   FractionTree.node(15/13r).parents => [(8/7), (7/6)]
+    #   FractionTree.node(Math::PI).parents => [(1181999955934188/376242271442657), (1959592697655605/623757728557343)]
+    #
+    def parents
+      tmp = path
+      [tmp[-2], tmp[-2..-1].inject(&:-)].sort
+    end
+
+    # @return [Array] of [FractionTree::Node], sequence of Farey neighbors to self. A Farey neighbor is a number c/d, who's relationship to a/b is such that ad − bc = 1, when c/d < a/b and bc − ad = 1 when c/d > a/b.
+    # @example
+    #   FractionTree.node(3/2r).neighbors(10)
+    #   => [(1/1), (2/1), (4/3), (5/3), (7/5), (8/5), (10/7), (11/7), (13/9), (14/9)]
+    # @param r range of harmonic series to search
+    #
+    def neighbors(r = 10**(self.class.decimal_power(number.numerator)+2))
+      ratio = number.to_r
+      denominator = ratio.denominator
+
+      [].tap do |collection|
+        (1..r-1).each do |i|
+          lower, upper = self.class.plus_minus(ratio, Rational(1,i*denominator))
+          collection << tree.node(lower) if tree.neighbors?(ratio, lower)
+          collection << tree.node(upper) if tree.neighbors?(ratio, upper)
+        end
+      end
+    end
+
+    # @return [Array] the ancestors shared by self and the given number
+    # @example
+    #   FractionTree.node(4/3r).common_ancestors_with(7/4r)
+    #   => [(0/1), (1/0), (1/1), (2/1), (3/2)]
+    #
+    # @param num [Numeric] other number sharing descendants with self
+    #
+    def common_ancestors_with(num)
+      path & tree.node(num).path
+    end
+
+    # @return [Array] of fraction tree nodes, descending from parents of number
+    # @example
+    #   FractionTree.node(5/4r).descendancy_from(depth: 3)
+    #   => [(1/1), (7/6), (6/5), (11/9), (5/4), (14/11), (9/7), (13/10), (4/3)]
+    #
+    # @param depth [Integer] how many nodes to collect
+    #
+    def descendancy_from(depth: 5)
+      (parent1, parent2) = parents
+      tree.descendants_of(parent1.number, parent2.number, depth:)
+    end
+
+    # @return [FractionTree::Node] child of self and given number
+    # @example
+    #   FractionTree.node(5/4r).child_with(4/3r)
+    #   => (9/7)
+    # @note return nil if bc - ad |= 1, for a/b, c/d
+    #
+    def child_with(num)
+      tree.child_of(number, num)
+    end
+
+    # @return [String] encoding of self
+    # @example
+    #   FractionTree.node(Math.log2(5/4r)).encoding(limit: 30) => "LLLRRRRRRRRRLLRRLLLLRRRRRRLLRL"
+    # @param limit of codes to generate
+    #
+    def encoding(limit: Float::INFINITY)
+      self.class.encode(number, limit:)
+    end
+
+    # @return [FractionTree::Node] sum of self and another node
+    # @example
+    #   FractionTree.node(5/4r) + FractionTree.node(3/2r)
+    #   => (4/3)
+    #
+    def +(rhs)
+      tree.node(Rational(self.numerator+rhs.numerator, self.denominator+rhs.denominator))
+    end
+
+    # @return [FractionTree::Node] difference of self and another node
+    # @example
+    #   FractionTree.node(5/4r) - FractionTree.node(3/2r)
+    #   => (1/1)
+    #
+    def -(rhs)
+      tree.node(Rational((self.numerator-rhs.numerator).abs, (self.denominator-rhs.denominator).abs))
+    end
+
+    def inspect
+      "(#{numerator}/#{denominator})"
+    end
+    alias :to_s :inspect
+
+    def <=>(rhs)
+      self.number <=> rhs.number
+    end
+
+    def ==(rhs)
+      self.number == rhs.number
+    end
+
+    # Needed for intersection operations to work.
+    # https://blog.mnishiguchi.com/ruby-intersection-of-object-arrays
+    # https://shortrecipes.blogspot.com/2006/10/ruby-intersection-of-two-arrays-of.html
+    # Also, allows using with Set, which uses Hash as storage and equality of its elements is determined according to Object#eql? and Object#hash.
+    #
+    def eql?(rhs)
+       rhs.instance_of?(self.class) && number == rhs.number
+    end
+
+    def hash
+       p, q = 17, 37
+       p = q * @id.hash
+       p = q * @name.hash
+    end
+
+    private
+    def tree
+      FractionTree
+    end
+
+    def fraction_pair(number)
+      if number.infinite?
+        [1, 0]
+      else
+        [number.numerator, number.denominator]
+      end
+    end
+  end
+end

data/lib/fraction_tree.rb

@@ -1,325 +1,7 @@
+require "matrix"
+require "forwardable"
 require "bigdecimal/util"
 require "continued_fractions"
-
-# @author Jose Hales-Garcia
-#
-class FractionTree
-  DEFAULT_TREE_DEPTH = 20
-
-  class << self
-    # @return [Array] the boundary nodes of the tree
-    # @example
-    #   FractionTree.base_segment => [(0/1), (1/0)]
-    #
-    def base_segment
-      [Node.new(0,1), Node.new(1,0)]
-    end
-
-    # @return [Array] a multi-dimensional array with the elements of fraction tree, organized by level/row
-    # @example
-    #   FractionTree.tree(4)
-    #   => [[(0/1), (1/0)],
-    #       [(1/1)],
-    #       [(1/2), (2/1)],
-    #       [(1/3), (2/3), (3/2), (3/1)]]
-    #
-    # @param number [Integer] the depth of the tree
-    #
-    def tree(depth=DEFAULT_TREE_DEPTH)
-      Array.new(depth, 0).tap do |sbt|
-        row = 0
-        sbt[row] = base_segment
-        i = 2
-        while i <= depth do
-          figure_from = sbt[0..row].flatten.sort
-          new_frow = Array.new(2**(i-2), 0)
-          idx = 0
-          figure_from.each_cons(2) do |left,right|
-            new_frow[idx] = Node.new(left.numerator+right.numerator, left.denominator+right.denominator)
-            idx += 1
-          end
-          row += 1
-          sbt[row] = new_frow
-          i += 1
-        end
-      end
-    end
-
-    # @return [Array] a sequence of fraction tree nodes
-    # @example
-    #   FractionTree.sequence(3)
-    #     => [(0/1), (1/3), (1/2), (2/3), (1/1), (3/2), (2/1), (3/1), (1/0)]
-    #
-    # @param depth [Integer] the number of iterations of the algorithm to run. The number of nodes returned will be greater
-    # @param segment [Array] a tuple array of [FractionTree::Node] defining the segment of the tree to collect nodes.
-    #
-    def sequence(depth=5, segment: base_segment)
-      [segment.first]+_sequence(depth, segment:)+[segment.last]
-    end
-
-    # @return [Array] set of fraction nodes leading to the given number
-    # @example 
-    #    FractionTree.path_to(7/4r) => [(1/1), (2/1), (3/2), (5/3), (7/4)]
-    #
-    # @param number [Rational] the target the fraction path leads to
-    # @param find_parents [Boolean] list all ancestors or only immediate parents
-    # @param segment [Array] a tuple of [FractionTree::Node], defining the segment's starting left and right boundaries
-    #
-    def path_to(number, find_parents: false, segment: base_segment)
-      return Node.new(number.numerator, number.denominator) if number.zero?
-      number = number.kind_of?(Float) ? number.to_d : number
-
-      q = Node.new(number.numerator, number.denominator)
-      l = segment.first
-      h = segment.last
-      not_found = true
-      parents = []
-      results = []
-      while not_found
-        m = (l + h)
-        if m < q
-          l = m
-        elsif m > q
-          h = m
-        else
-          parents << l << h
-          not_found = false
-        end
-        results << m
-      end
-      find_parents == false ? results : parents
-    end
-
-    # @return [Array] a pair of fraction tree nodes leading to the given number.
-    #   For irrational numbers, the parent nodes are one of an infinite series, whose nearness is determined by the limits of the system
-    # @example
-    #   FractionTree.parents_of(15/13r) => [(8/7), (7/6)]
-    #   FractionTree.parents_of(Math::PI) => [(447288330638589/142376297616907), (436991388364966/139098679093749)]
-    #
-    # @param number [Rational] the child number whose parents are being sought
-    #
-    def parents_of(number)
-      path_to(number, find_parents: true)
-    end
-
-    # @return [Array] the ancestors shared by the given descendants
-    # @example
-    #   FractionTree.common_ancestors_between(4/3r, 7/4r)
-    #   => [(1/1), (2/1), (3/2)]
-    #
-    # @param number1 [Rational] one of two descendants
-    # @param number2 [Rational] two of two descendants
-    #
-    def common_ancestors_between(number1, number2)
-      path_to(number1) & path_to(number2)
-    end
-
-    # @return [Array] the descendants of number starting at its parents
-    # @example
-    #   FractionTree.descendancy_from(5/4r, 3)
-    #   => [(1/1), (7/6), (6/5), (11/9), (5/4), (14/11), (9/7), (13/10), (4/3)]
-    #
-    # @param number [Rational] around which descendancy is focused
-    # @param depth [Integer] how many nodes to collect
-    #
-    def descendancy_from(number, depth=5)
-      parent1, parent2 = parents_of(number)
-      descendants_of(parent1, parent2, depth)
-    end
-
-    # @return [FractionTree::Node] the mediant child of the given numbers
-    #   Return nil if bc - ad |= 1, for a/b, c/d
-    # @example
-    #   FractionTree.child_of(1/1r, 4/3r) => (5/4)
-    #   FractionTree.child_of(7/4r, 4/3r) => nil
-    #
-    # @param number1 [Rational] one of two parents
-    # @param number2 [Rational] two of two parents
-    # @param strict_neighbors [Boolean] whether to apply the strict Farey tree neighbor requirement
-    #
-    def child_of(number1, number2, strict_neighbors: true)
-      return nil unless farey_neighbors?(number1, number2) || !strict_neighbors
-      Node.new(number1.numerator, number1.denominator) + Node.new(number2.numerator, number2.denominator)
-    end
-
-    # @return [Array] of nodes descended from parent1 and parent2
-    #   Return empty array if bc - ad |= 1, for a/b, c/d
-    # @example
-    #   FractionTree.descendants_of(1/1r, 4/3r, 3)
-    #   => [(1/1), (7/6), (6/5), (11/9), (5/4), (14/11), (9/7), (13/10), (4/3)]
-    #
-    # @param parent1 [Rational] one of two parents
-    # @param parent2 [Rational] two of two parents
-    # @param depth [Integer] the depth to collect
-    # @param strict_neighbors [Boolean] whether to apply the strict Farey tree neighbor requirement
-    #
-    def descendants_of(parent1, parent2, depth=5, strict_neighbors: true)
-      return [] unless farey_neighbors?(parent1, parent2) || !strict_neighbors
-      segment = [Node.new(parent1.numerator, parent1.denominator), Node.new(parent2.numerator, parent2.denominator)]
-      sequence(depth, segment: segment)
-    end
-
-    # @return [Array] of FractionTree::Nodes leading quotient-wise to number
-    # @example
-    #   FractionTree.quotient_walk(15/13r)
-    #   => [(1/1), (2/1), (3/2), (4/3), (5/4), (6/5), (7/6), (8/7), (15/13)]
-    #
-    # @param number [Numeric] to walk toward
-    # @param limit [Integer] the depth of the walk. Useful for irrational numbers
-    # @param segment [Array] the tuple of [FractionTree::Node] defining the segment of the tree
-    #
-    def quotient_walk(number, limit: 10, segment: computed_base_segment(number))
-      iterating_quotients = ContinuedFraction.new(number, limit).quotients.drop(1)
-      comparing_node = Node.new(number.numerator, number.denominator)
-
-      segment.tap do |arr|
-        held_node = arr[-2]
-        moving_node = arr[-1]
-
-        iterating_quotients.each do |q|
-          (1..q).each do |i|
-            arr << held_node + moving_node
-            # We don't want to walk past the number when it's a rational number and we've reached it
-            break if arr.include?(comparing_node)
-            moving_node = arr[-1]
-          end
-          held_node = arr[-2]
-        end
-      end
-    end
-
-    # @return [Array] of numerators of the fraction tree nodes. Also known as the Stern-Brocot sequence.
-    # @example
-    #   FractionTree.numeric_sequence.take(12)
-    #   => [1, 1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2]
-    #
-    def numeric_sequence
-      return enum_for :numeric_sequence unless block_given?
-      a=[1,1]
-
-      0.step do |i|
-        yield a[i]
-        a << a[i]+a[i+1] << a[i+1]
-      end
-    end
-
-    # @return [Array] of Farey neighbors to the given number. A Farey neighbor is a number b/c, who's relationship to a/b is such that ad − bc = 1, when c/d < a/b and bc − ad = 1 when c/d > a/b.
-    # @example
-    #   FractionTree.farey_neighbors(3/2r, 10)
-    #   => [(1/1), (2/1), (4/3), (5/3), (7/5), (8/5), (10/7), (11/7), (13/9), (14/9)]
-    # @param number with neighbors
-    # @param range of harmonic series to search
-    #
-    def farey_neighbors(number, range = 10**(decimal_power(number.numerator)+2))
-      ratio = number.to_r
-      denominator = ratio.denominator
-
-      [].tap do |collection|
-        (1..range-1).each do |i|
-          lower, upper = plus_minus(ratio, Rational(1,i*denominator))
-          collection << lower if farey_neighbors?(ratio, lower)
-          collection << upper if farey_neighbors?(ratio, upper)
-        end
-      end
-    end
-
-    # @return [Boolean] whether two numbers are Farey neighbors
-    # @example
-    #   FractionTree.farey_neighbors?(3/2r, 4/3r) => true
-    #   FractionTree.farey_neighbors?(3/2r, 7/4r) => false
-    # @param num1 of comparison
-    # @param num2 of comparison
-    #
-    def farey_neighbors?(num1, num2)
-      (num1.numerator * num2.denominator - num1.denominator * num2.numerator).abs == 1
-    end
-
-    private
-    def computed_base_segment(number)
-      floor = number.floor
-      [Node.new(floor,1), Node.new(floor+1,1)]
-    end
-
-    def _sequence(depth = 5, segment:)
-      return [] if depth == 0
-
-      mediant = segment.first + segment.last
-
-      # Generate left segment, mediant, then right segment
-      _sequence(depth - 1, segment: [segment.first, mediant]) + [mediant] + _sequence(depth - 1, segment: [mediant, segment.last])
-    end
-
-    def plus_minus(number, diff)
-      [number - diff, number + diff]
-    end
-
-    def decimal_power(number)
-      Math.log10(number.abs).floor
-    end
-  end
-
-  class Node
-    include Comparable
-
-    attr_reader :numerator, :denominator, :weight
-
-    def initialize(n,d)
-      @numerator = n
-      @denominator = d
-      @weight = (d == 0 ? Float::INFINITY : Rational(@numerator, @denominator))
-    end
-
-    alias :to_r :weight
-
-    def inspect
-      "(#{numerator}/#{denominator})"
-    end
-    alias :to_s :inspect
-
-    def <=>(rhs)
-      self.weight <=> rhs.weight
-    end
-
-    def ==(rhs)
-      self.weight == rhs.weight
-    end
-
-    # Needed for intersection operations to work.
-    # https://blog.mnishiguchi.com/ruby-intersection-of-object-arrays
-    # https://shortrecipes.blogspot.com/2006/10/ruby-intersection-of-two-arrays-of.html
-    # Also, allows using with Set, which uses Hash as storage and equality of its elements is determined according to Object#eql? and Object#hash.
-    #
-    def eql?(rhs)
-       rhs.instance_of?(self.class) && weight == rhs.weight
-    end
-
-    def hash
-       p, q = 17, 37
-       p = q * @id.hash
-       p = q * @name.hash
-    end
-
-    def +(rhs)
-      self.class.new(self.numerator+rhs.numerator, self.denominator+rhs.denominator)
-    end
-  end
-end
-
-class SternBrocotTree < FractionTree; end
-class ScaleTree < FractionTree; end
-
-class OctaveReducedTree < FractionTree
-  def self.base_segment
-    [Node.new(1,1), Node.new(2,1)]
-  end
-end
-
-class FareyTree < FractionTree
-  def self.base_segment
-    [Node.new(0,1), Node.new(1,1)]
-  end
-end
-
-class KeyboardTree < FareyTree; end
-class ScaleStepTree < FareyTree; end
-class Log2Tree < FareyTree; end
+require_relative "fraction_tree/node"
+require_relative "fraction_tree/extensions"
+require_relative "fraction_tree/fraction_tree"

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: fraction-tree
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Jose Hales-Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2024-09-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: continued_fractions
   requirement: !ruby/object:Gem::Requirement
@@ -87,6 +115,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/fraction_tree.rb
+- lib/fraction_tree/extensions.rb
+- lib/fraction_tree/fraction_tree.rb
+- lib/fraction_tree/node.rb
 homepage: https://jolohaga.github.io/fraction-tree/
 licenses:
 - MIT
@@ -107,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '3.1'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: Fraction tree