unodos 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1d6382656d25e32af8472594431238876b8d272f5e1dd3f11a4280dba447ec1
+  data.tar.gz: 833359582ee40ccc6bcd9aa8c0ff4ad31ef4a5669e0221ffe374e38d2be21ba9
+SHA512:
+  metadata.gz: 7c1940eb0e70201528757a3ef91eec0fbc573a70813bf8b0eb88f8e6837ef741840be93a29226fc02101771b6adbdc956cc900c4b9096d95c6f642b43796eca9
+  data.tar.gz: 5a79be567967b770e3441430960913e8cbd35718d246f2d31db349bdba5310b3c786905d3855013e49d4523c0aee835eb3c4b9d4d0dc1e2cf1e3e803bdff2ea2

data/.gitignore

@@ -0,0 +1 @@
+coverage/

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unodos.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'
+gem 'minitest', '~> 5.0'
+gem 'simplecov'

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    unodos (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.3.2)
+    json (2.3.0)
+    minitest (5.13.0)
+    rake (12.3.3)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 12.0)
+  simplecov
+  unodos!
+
+BUNDLED WITH
+   2.1.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 tompng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Unodos
+
+```ruby
+require 'unodos'
+Unodos[1,2,3].take(5) # => [1,2,3,4,5]
+Unodos[1,2,4].take(5) # => [1,2,4,8,16]
+Unodos[1,1,2,3,5].take(8) # => [1,1,2,3,5,8,13,21]
+Unodos[1,1,2,4,3,9,4,16,5].take(10) #=> [1,1,2,4,3,9,4,16,5,25]
+
+# to see the generated rule
+Unodos[4,1,0,1,4,9].rule #=> "a[n]=4-4*n+n**2"
+Unodos[1,2,4,5,7,8].rule #=> "a[n]=-a[n-1]+3*n"
+```
+
+## Installation
+
+```ruby
+gem 'unodos'
+```
+
+## Syntax Sugar
+
+```ruby
+require 'unodos/sugar' # will add Array#infinite
+[1,2,3].infinite.take(5) #=> [1,2,3,4,5]
+using Unodos::Sugar # will change [numbers, number..].some_method
+[1,2,3..].take(5) #=> [1,2,3,4,5]
+[1,1,2,3,5..].find_index(144) #=> 11
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'unodos'
+require 'unodos/sugar'
+using Unodos::Sugar
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/unodos/base.rb

@@ -0,0 +1,30 @@
+module Unodos
+  class NamedBase
+    attr_reader :name, :proc
+
+    def initialize(name, &block)
+      @name = name
+      @proc = block
+    end
+
+    def differential_level
+      0
+    end
+
+    alias to_s name
+    alias inspect name
+  end
+
+  class DifferentialBase
+    attr_reader :differential_level
+    def initialize(level)
+      @differential_level = level
+    end
+
+    def to_s
+      "a[n-#{differential_level}]"
+    end
+
+    alias inspect to_s
+  end
+end

data/lib/unodos/formatter.rb

@@ -0,0 +1,26 @@
+module Unodos::Formatter
+  def self.format_rational(n, wrap: false)
+    return '0' if n == 0
+    return n.inspect unless n.is_a? Rational
+    return n.numerator.inspect if n.denominator == 1
+    s = "#{n.numerator.abs}/#{n.denominator}"
+    s = "(#{s})" if wrap
+    s = '-' + s if n < 0
+    s
+  end
+
+  def self.format(n, wrap: false)
+    return '0' if n == 0
+    if n.imag == 0
+      format_rational n.real, wrap: wrap
+    elsif n.real == 0
+      format_rational(n.imag, wrap: true) + 'i'
+    else
+      r = format_rational(n.real)
+      i = format_rational(n.imag, wrap: true)
+      s = r + (n.imag > 0 ? '+' : '') + i + 'i'
+      s = "(#{s})" if wrap
+      s
+    end
+  end
+end

data/lib/unodos/infinite.rb

@@ -0,0 +1,75 @@
+require_relative 'formatter'
+require_relative 'solver'
+
+class Unodos::Infinite < Enumerator
+  attr_reader :cost, :elements, :differential_level, :initial
+  def initialize(list)
+    min_cost = list.size + 1
+    result = nil
+    list.size.times do |level|
+      cost, res = Unodos::Solver.solve list, level, min_cost
+      if cost && cost < min_cost
+        min_cost = cost
+        result = res
+      end
+    end
+    @cost = min_cost
+    @elements = result.map do |(_, _, base), v|
+      v = v.real.to_i if v.real.to_i == v
+      [base, v] if v != 0
+    end.compact
+    @differential_level = @elements.map(&:first).map(&:differential_level).max
+    @initial = list.take(@differential_level)
+  end
+
+  def rule
+    es = @elements.map.with_index do |(base, v), i|
+      sign = i != 0
+      name = base.to_s
+      s = if name == '1'
+        Unodos::Formatter.format v
+      elsif v == 1
+        name
+      elsif v == -1
+        '-' + name
+      else
+        Unodos::Formatter.format(v, wrap: true) + '*' + name
+      end
+      i == 0 || '-+'.include?(s[0]) ? s : '+' + s
+    end
+    "a[n]=#{es.join}"
+  end
+
+  def inspect
+    if differential?
+      "[#{[*initial, rule].join(', ')}]"
+    else
+      rule
+    end
+  end
+
+  def differential?
+    differential_level > 0
+  end
+
+  def each(&block)
+    Enumerator.new do |y|
+      differential = [0] * differential_level
+      (0..).each do |i|
+        v = if i < differential_level
+          initial[i]
+        else
+          elements.sum do |base, v|
+            if base.differential_level > 0
+              v * differential[(i - base.differential_level) % differential_level]
+            else
+              v * base.proc.call(i)
+            end
+          end
+        end
+        differential[i % differential_level] = v if differential?
+        y << v
+      end
+    end.each(&block)
+  end
+end

data/lib/unodos/solver.rb

@@ -0,0 +1,169 @@
+require_relative 'base'
+module Unodos::Solver
+  TOLERANCE = 1e-12
+  NAMED_BASES = [
+    Unodos::NamedBase.new('1') { |_| 1 },
+    Unodos::NamedBase.new('n') { |n| n },
+    Unodos::NamedBase.new('n**2') { |n| n**2 },
+    Unodos::NamedBase.new('n**3') { |n| n**3 },
+    Unodos::NamedBase.new('n**4') { |n| n**4 },
+    Unodos::NamedBase.new('n**5') { |n| n**5 },
+    Unodos::NamedBase.new('2**n') { |n| 2**n },
+  ]
+
+  def self.lup_solve(lup, b)
+    size = b.size
+    m = b.values_at(*lup.pivots)
+    mat_l = lup.l
+    mat_u = lup.u
+    size.times do |k|
+      (k + 1).upto(size - 1) do |i|
+        m[i] -= m[k] * mat_l[i, k]
+      end
+    end
+    (size - 1).downto(0) do |k|
+      next if m[k] == 0
+      return nil if mat_u[k, k].zero?
+      m[k] = m[k].quo mat_u[k, k]
+      k.times do |i|
+        m[i] -= m[k] * mat_u[i, k]
+      end
+    end
+    m
+  end
+
+  def self.solve(list, differential_level, min_cost)
+    base_cost = differential_level
+    max_items = min_cost - base_cost - 1
+    return nil if max_items <= 0
+    result = nil
+    vector_max_bases = NAMED_BASES.map do |base|
+      vector = (differential_level..list.size-1).map do |i|
+        base.proc.call(i)
+      end
+      [vector, vector.map(&:abs).max, base]
+    end
+    if differential_level > 0
+      (1..differential_level).each do |level|
+        vector = list.take(list.size - level).drop(differential_level - level)
+        vector_max_bases.unshift [vector, vector.map(&:abs).max, Unodos::DifferentialBase.new(level)]
+      end
+      list = list.drop differential_level
+    end
+    select_solve vector_max_bases.map(&:first), list, max_items, differential_level > 0 do |vs, pos|
+      rs = vector_max_bases.values_at(*pos).zip(vs)
+      rs.each { |r| r[1] = 0 if (r[0][1] * r[1]).abs < TOLERANCE }
+      next if differential_level > 0 && rs[0][1] == 0
+      cost = rs.sum { |(_, _, base), v| v == 0 ? 0 : 1 } + base_cost
+      if cost < min_cost
+        min_cost = cost
+        result = rs
+      end
+    end
+    [min_cost, result] if result
+  end
+
+  def self.match_vector(vector, bvector)
+    v, b = vector.zip(bvector).max_by { |a,| a.abs }
+    a = b.quo v
+    err = vector.zip(bvector).map { |v, b| (v * a - b).abs }.max
+    a if err < TOLERANCE
+  end
+
+  def self.find_solve(vectors, bvector, &block)
+    (1...vectors.size).each do |i|
+      least_square_solve [vectors[0], vectors[i]], bvector do |vs, pos|
+        block.call vs, pos.map { |c| c == 1 ? i : 0 }
+      end
+    end
+  end
+
+  def self.select_solve(vectors, bvector, max_items, first_required, &block)
+    if first_required && max_items == 1
+      a = match_vector vectors[0], bvector
+      block.call [a], [0] if a
+    elsif vectors.size < bvector.size
+      least_square_solve vectors, bvector, &block
+    elsif first_required && max_items == 2
+      find_solve vectors, bvector, &block
+    elsif
+      recursive_solve vectors, bvector, first_required, &block
+    end
+  end
+
+  def self.least_square_solve(vectors, bvector, &block)
+    mat = Matrix[*vectors.transpose]
+    tmat = mat.transpose
+    m = tmat * mat
+    b = tmat * Vector[*bvector]
+    vs = lup_solve m.lup, b.to_a
+    return unless vs
+    max_diff = bvector.each_with_index.map do |bv, i|
+      (vectors.zip(vs).sum { |a, v| v * a[i] } - bv).abs
+    end.max
+    block.call vs, (0...vectors.size).to_a if max_diff < TOLERANCE
+  end
+
+  def self.recursive_solve(vectors, bvector, first_required, &block)
+    return least_square_solve vectors, bvector, &block if vectors.size < bvector.size
+    size = vectors.size
+    out_size = bvector.size
+    skip_size = size - out_size
+    lup = Matrix[*vectors.transpose].lup
+    mat_l = lup.l
+    mat_u = lup.u.to_a
+    bvector = bvector.values_at(*lup.pivots)
+    out_size.times do |k|
+      (k + 1).upto(out_size - 1) do |i|
+        bvector[i] -= bvector[k] * mat_l[i, k]
+      end
+    end
+    solved = lambda do |u, selected|
+      b = bvector.dup
+      (selected.size - 1).downto 0 do |i|
+        j = selected[i]
+        next if b[i] == 0
+        return if u[i][j] == 0
+        b[i] = b[i].quo u[i][j]
+        i.times do |k|
+          b[k] -= b[i] * u[k][j]
+        end
+      end
+      block.call b, selected
+    end
+    solve = lambda do |u, selected, index|
+      return solved.call u, selected if selected.size == out_size
+      j = selected.size
+      restore_index = (j .. [index, out_size - 1].min).max_by do |k|
+        u[k][index].abs
+      end
+      u[j], u[restore_index] = u[restore_index], u[j]
+      bvector[j], bvector[restore_index] = bvector[restore_index], bvector[j]
+      restore = (j + 1 .. [index, out_size - 1].min).map do |k|
+        v = u[j][index] == 0 ? 0 : u[k][index].quo(u[j][index])
+        (index + 1 ... size).each do |l|
+          u[k][l] -= v * u[j][l]
+        end
+        bvector[k] -= v * bvector[j]
+        [k, v]
+      end
+      selected.push index
+      solve.call u, selected, index + 1
+      selected.pop
+      restore.reverse_each do |k, v|
+        (index + 1 ... size).each do |l|
+          u[k][l] += v * u[j][l]
+        end
+        bvector[k] += v * bvector[j]
+      end
+      u[j], u[restore_index] = u[restore_index], u[j]
+      bvector[j], bvector[restore_index] = bvector[restore_index], bvector[j]
+      solve.call u, selected, index + 1 if size - index > out_size - selected.size
+    end
+    if first_required
+      solve.call mat_u, [0], 1
+    else
+      solve.call mat_u, [], 0
+    end
+  end
+end

data/lib/unodos/sugar.rb

@@ -0,0 +1,27 @@
+class Array
+  def infinite(&block)
+    inf = Unodos::Infinite.new(self)
+    block ? inf.each(&block) : inf
+  end
+end
+
+module Unodos::Sugar
+  def self.target_array?(array)
+    last = array.last
+    return false unless array.size >= 2 && last.is_a?(Range) && last.end.nil?
+    *items, _ = array
+    items.all?(Numeric)
+  end
+  refine Array do
+    %i[each map take find_index first take_while].each do |method|
+      define_method method do |*args, **kwargs, &block|
+        if Unodos::Sugar.target_array? self
+          *items, last = self
+          Unodos::Infinite.new(items + [last.begin]).send(method, *args, **kwargs, &block)
+        else
+          super(*args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/unodos/version.rb

@@ -0,0 +1,3 @@
+module Unodos
+  VERSION = "0.1.0"
+end

data/lib/unodos.rb

@@ -0,0 +1,8 @@
+require 'matrix'
+require "unodos/version"
+require "unodos/infinite"
+module Unodos
+  def self.[](*list)
+    Unodos::Infinite.new(list)
+  end
+end

data/unodos.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/unodos/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "unodos"
+  spec.version       = Unodos::VERSION
+  spec.authors       = ["tompng"]
+  spec.email         = ["tomoyapenguin@gmail.com"]
+
+  spec.summary       = %q{Infinite number sequence generator}
+  spec.description   = %q{Infinite number sequence generator}
+  spec.homepage      = "https://github.com/tompng/unodos"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: unodos
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tompng
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-30 00:00:00.000000000 Z
+dependencies: []
+description: Infinite number sequence generator
+email:
+- tomoyapenguin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/unodos.rb
+- lib/unodos/base.rb
+- lib/unodos/formatter.rb
+- lib/unodos/infinite.rb
+- lib/unodos/solver.rb
+- lib/unodos/sugar.rb
+- lib/unodos/version.rb
+- unodos.gemspec
+homepage: https://github.com/tompng/unodos
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tompng/unodos
+  source_code_uri: https://github.com/tompng/unodos
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Infinite number sequence generator
+test_files: []