halton 0.2.1.4-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc997682f9f9dc57e833b1258d7e8c2f5f0834bdbed5747602c359ce54873781
+  data.tar.gz: 52fe97c9e6d1db1318d68517b915ee3cf4fb20d7442dadd786a1fc170d3b503e
+SHA512:
+  metadata.gz: e0f18725329c54a6571dfcf003e6447a3fbf1b67b14c6a6900ca7a96cc0bc546073d0f48bb9f905ccc95d263d846324b733732c22591d669b38ba5ea39f6b769
+  data.tar.gz: d894ba41bbde97f2addefdf5ee959a8df2bdd3893cfa6ba5b2fed3d0229ef0c441bd1668a9be907fbbfadce79e4de85d58c79085bfdd2c2f98df7d6300a66765

data/README.rdoc

@@ -0,0 +1,45 @@
+= Halton
+
+A Ruby library for the fast generation of Halton sequences, a deterministic low
+discrepancy sequence that appears to be random. The uniform distribution and
+repeatability makes the sequence ideal for choosing sample points or placing
+objects in 2D or 3D space.
+
+  grid = 10.times.map {10.times.map {"."}}
+  Halton.each(2, 3).take(26).zip("A".."Z") do |(x, y), c|
+    grid[y * 10][x * 10] = c
+  end
+  grid.each {|row| puts row.join(" ")}
+
+Outputs:
+
+  . . R . . I . . . .
+  . L . . . . U C . .
+  X . . F . . . . . O
+  . . . J . A . . . .
+  . D . . . . M S . .
+  P . . . V . . . G .
+  . . B . . Y . . . .
+  . T . . . . E . K .
+  H . . . N . . . . W
+  . . . Z . Q . . . .
+
+The method of generation is adapted from "Fast, portable, and reliable
+algorithm for the calculation of Halton numbers" by Miroslav Kolář and Seamus F.
+O'Shea.
+
+== Install
+
+Install via Rubygems:
+
+  gem install halton
+
+or add it to your Gemfile if you're using Bundler:
+
+  gem "halton"
+
+and then run the bundle command to install.
+
+This gem requires a Rust compiler and the +cargo+ build tool to build the gem's
+native extension. See https://www.rust-lang.org/tools/install for how to
+install Rust. +cargo+ is usually part of the Rust installation.

data/lib/halton.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+begin
+  /(?<ruby_version>\d+\.\d+)/ =~ RUBY_VERSION
+  require_relative "halton/#{ruby_version}/halton"
+rescue LoadError
+  require_relative "halton/halton"
+end
+
+# The Halton module provides methods for generating Halton sequences, a
+# deterministic low discrepancy sequence that appears to be random. The uniform
+# distribution and repeatability makes the sequence ideal for choosing sample
+# points or placing objects in 2D or 3D space.
+#
+#   grid = 10.times.map {10.times.map {"."}}
+#   Halton.each(2, 3).take(26).zip("A".."Z") do |(x, y), c|
+#     grid[y * 10][x * 10] = c
+#   end
+#   grid.each {|row| puts row.join(" ")}
+#
+# Outputs:
+#
+#   . . R . . I . . . .
+#   . L . . . . U C . .
+#   X . . F . . . . . O
+#   . . . J . A . . . .
+#   . D . . . . M S . .
+#   P . . . V . . . G .
+#   . . B . . Y . . . .
+#   . T . . . . E . K .
+#   H . . . N . . . . W
+#   . . . Z . Q . . . .
+#
+module Halton
+
+  ##
+  # :singleton-method: number
+  # :call-seq: Halton.number(base, index) -> int
+  #
+  # Returns the number at +index+ of the Halton sequence for +base+. The number
+  # returned will be > 0 and < 1, assuming +index+ > 1.
+  #
+  # While #each will be faster for most cases, this function may be
+  # useful for calulating a single number from a Halton sequence, or creating
+  # a 'leaped' sequence.
+  #
+  # 'leaped' Halton sequence:
+  #
+  #   step = 409;
+  #   i = 1;
+  #   while i < 10 * step
+  #     puts Halton.number(17, i)
+  #     i += step
+  #   end
+  #
+  # Beware that indexing #each is effectively 0-based, whereas the
+  # `index` argument for [`number`] is 1-based.
+  #
+  #   Halton.each(2).take(10)[2]   #=> 0.75
+  #   Halton.number(2, 3)          #=> 0.75
+
+  # :call-seq:
+  # Halton.each(base) {|n| ... }
+  # Halton.each(base_x, base_y) {|x, y| ... }
+  # Halton.each(base_x, base_y, base_z) {|x, y, z| ... }
+  # Halton.each(*bases) {|*n| ... }
+  # Halton.each(*bases) -> Enumerator
+  #
+  # Implements the fast generation of Halton sequences.
+  # The method of generation is adapted from "Fast, portable, and reliable
+  # algorithm for the calculation of Halton numbers" by Miroslav Kolář and
+  # Seamus F. O'Shea.
+  #
+  # The numbers yielded will be in the range > 0 and < 1.
+  #
+  def self.each(base, *bases, &block)
+    case bases.length
+    when 0
+      each_one(base, &block)
+    when 1
+      each_pair(base, bases.first, &block)
+    when 2
+      each_triple(base, bases.first, bases.last, &block)
+    else
+      each_many(*bases.unshift(base), &block)
+    end
+  end
+
+  # Halton::Sequence implements the fast generation of Halton sequences.
+  # The method of generation is adapted from "Fast, portable, and reliable
+  # algorithm for the calculation of Halton numbers" by Miroslav Kolář and
+  # Seamus F. O'Shea.
+  #
+  # This class is implemented as a stateful iterator, a pattern not common in
+  # Ruby. The Halton::each method provides a more friendly interface to this
+  # class.
+  #
+  class Sequence
+
+    ##
+    # :singleton-method: new
+    # :call-seq: Sequence.new(base) -> sequence
+    #
+    # Create a new Halton::Sequence.
+
+    ##
+    # :method: next
+    # :call-seq: sequence.next -> int
+    #
+    # Get the next number in the sequence. The numbers will be in the range > 0
+    # and < 1.
+    #
+    # Will raise StopIteration when the sequence has ended.
+
+    ##
+    # :method: skip
+    # :call-seq: sequence.skip(n) -> nil
+    #
+    # Can be used to efficiently skip large sections of the sequence. For small
+    # values of +n+ simply advances the sequence +n+ times.
+
+    ##
+    # :method: remaining
+    # :call-seq: sequence.remaining -> int or nil
+    #
+    # Returns the count of the remaining numbers in the sequence. May return
+    # +nil+ if the count is larger than the host platform's native unsigned
+    # integer type.
+
+  end
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: halton
+version: !ruby/object:Gem::Version
+  version: 0.2.1.4
+platform: x64-mingw-ucrt
+authors:
+- Mat Sadler
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.46
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.46
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: A module implementing the fast generation of Halton sequences. The method
+  of generation is adapted from "Fast, portable, and reliable algorithm for the calculation
+  of Halton number" by Miroslav Kolář and Seamus F. O'Shea.
+email:
+- mat@sourcetagsandcodes.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- lib/halton.rb
+- lib/halton/3.1/halton.so
+homepage: https://github.com/matsadler/halton-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.rdoc
+- "--charset"
+- utf-8
+- "--exclude"
+- ext/
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.2.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Rust >= 1.51.0
+rubygems_version: 3.3.22
+signing_key:
+specification_version: 4
+summary: A module for generating Halton sequences
+test_files: []