halton 0.2.1.2 → 0.2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a65d2ef8aa05f9ff2b905cd199b67c457c22f6916be59df4fff97a92af0a48e
-  data.tar.gz: 15b62c7f8c05f1bcc9d206d3f228012fc1839a11095d6cc67cf046996696477c
+  metadata.gz: 367da6d10b20e537ed6a0bb6153bc95ab3c09313b9edd71736315708d60eafbe
+  data.tar.gz: ca90d4c261f13077f2294e23d14de023074649a4e0e39faa56ca550e6eeb0210
 SHA512:
-  metadata.gz: ca1ad0a5551d63dc6009b11afe17f8d792af1181564794c4a707bd9fdb08311459d73c3ff13dc76a7e067ac72fa510089a4bf8d09a093bf5f761af0d45284f8a
-  data.tar.gz: 11ebf433af39d7047da8c1cf99404bc09eb422ebc0f4e0c532ef0fdda96a7dbf37f89b09e01ca76c258dd03566f74653af7a096ece95d39117820b247bf36e21
+  metadata.gz: f936ff151b3964e44220d8a1036e0ed710eaf7821e633e361ef36b21307569c4be6bee16ee79cecc6c8492f6f69755745e91d953fd75e79308a0468a8fe63e0c
+  data.tar.gz: fa78a84ab664803a29762e9c968c5dd048f9655525f47134622a687fa7e9dfb9d86f169ab2ccb2fb7a2c8a279c2683c09d489344d5767e9cc689c1325bdd4445

data/ext/halton/Cargo.lock

@@ -172,7 +172,6 @@ name = "halton"
 version = "0.1.0"
 dependencies = [
  "halton 0.2.1",
- "lazy_static",
  "magnus",
 ]
 
@@ -242,9 +241,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.1.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1825dcc83398c263845f82fdf847f2599a6d51a4da6e668e5ca8e84309eea8df"
+checksum = "e772e3622600833393ebd9c89a5f963a9c9699528cb60764e7f178e0cc96344a"
 dependencies = [
  "bindgen",
  "magnus-macros",

data/ext/halton/Cargo.toml

@@ -9,5 +9,4 @@ crate-type = ["cdylib"]
 
 [dependencies]
 halton = "0.2.1"
-lazy_static = "1"
-magnus = "0.1.0"
+magnus = "0.3.1"

data/ext/halton/Rakefile

@@ -38,21 +38,47 @@ class RakeCargoHelper
     @cargo_target_dir = dir || "target"
   end
 
+  def self.flags
+    cc_flags = Shellwords.split(RbConfig.expand(RbConfig::MAKEFILE_CONFIG["CC"].dup))
+
+    ["-C", "linker=#{cc_flags.shift}",
+      *cc_flags.flat_map {|a| ["-C", "link-arg=#{a}"] },
+      "-L", "native=#{RbConfig::CONFIG["libdir"]}",
+      *dld_flags,
+      *platform_flags]
+  end
+
   def self.dld_flags
-    map = {"-L" => "-L native=", "-l" => "-l", "-F" => "-l framework="}
-    map.default_proc = proc {|_, key| "-C link_arg=#{key}"}
     Shellwords.split(RbConfig::CONFIG["DLDFLAGS"]).flat_map do |arg|
-      k, v = arg.split(/(?<=..)/, 2)
-      case k
-      when "-L"
-        [k, "native=#{v}"]
-      when "-l"
-        [k, v]
-      when "-F"
-        ["-l", "framework=#{v}"]
-      else
-        ["-C", "link_arg=#{k}#{v}"]
-      end
+      arg = arg.gsub(/\$\((\w+)\)/) do
+        $1 == "DEFFILE" ? nil : RbConfig::CONFIG[name]
+      end.strip
+      next [] if arg.empty?
+
+      transform_flag(arg)
+    end
+  end
+
+  def self.platform_flags
+    return unless RbConfig::CONFIG["target_os"] =~ /mingw/i
+
+    [*Shellwords.split(RbConfig::CONFIG["LIBRUBYARG"]).flat_map {|arg| transform_flag(arg)},
+      "-C", "link-arg=-Wl,--dynamicbase",
+      "-C", "link-arg=-Wl,--disable-auto-image-base",
+      "-C", "link-arg=-static-libgcc"]
+  end
+
+  def self.transform_flag(arg)
+    k, v = arg.split(/(?<=..)/, 2)
+    case k
+    when "-L"
+      [k, "native=#{v}"]
+    when "-l"
+      [k, v]
+    when "-F"
+      ["-l", "framework=#{v}"]
+    else
+      ["-C", "link_arg=#{k}#{v}"]
     end
   end
 
@@ -98,7 +124,7 @@ end
 
 desc "build gem native extension"
 task build: [:cargo, :cd] do
-  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--", *RakeCargoHelper.dld_flags
+  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--", *RakeCargoHelper.flags
 end
 
 desc "clean up release build artifacts"

data/ext/halton/src/lib.rs

@@ -1,6 +1,11 @@
 use std::cell::RefCell;
 
-use magnus::{define_module, function, method, prelude::*, Error};
+use magnus::{
+    block::{block_given, Yield, YieldSplat, YieldValues},
+    define_module, exception, function, method,
+    prelude::*,
+    Error, RArray, Value,
+};
 
 #[magnus::wrap(class = "Halton::Sequence", free_immediatly, size)]
 struct Sequence(RefCell<halton::Sequence>);
@@ -13,7 +18,10 @@ impl Sequence {
     fn next(&self) -> Result<f64, Error> {
         match self.0.try_borrow_mut().unwrap().next() {
             Some(f) => Ok(f),
-            None => Err(Error::stop_iteration("iteration reached an end")),
+            None => Err(Error::new(
+                exception::stop_iteration(),
+                "iteration reached an end",
+            )),
         }
     }
 
@@ -26,14 +34,88 @@ impl Sequence {
     }
 }
 
+fn each_one(rb_self: Value, base: u8) -> Yield<impl Iterator<Item = f64>> {
+    if !block_given() {
+        return Yield::Enumerator(rb_self.enumeratorize("each_one", (base,)));
+    }
+    Yield::Iter(halton::Sequence::new(base))
+}
+
+fn each_pair(
+    rb_self: Value,
+    x_base: u8,
+    y_base: u8,
+) -> YieldValues<impl Iterator<Item = (f64, f64)>> {
+    if !block_given() {
+        return YieldValues::Enumerator(rb_self.enumeratorize("each_pair", (x_base, y_base)));
+    }
+    let seq_x = halton::Sequence::new(x_base);
+    let seq_y = halton::Sequence::new(y_base);
+    YieldValues::Iter(seq_x.zip(seq_y))
+}
+
+fn each_triple(
+    rb_self: Value,
+    x_base: u8,
+    y_base: u8,
+    z_base: u8,
+) -> YieldValues<impl Iterator<Item = (f64, f64, f64)>> {
+    if !block_given() {
+        return YieldValues::Enumerator(
+            rb_self.enumeratorize("each_triple", (x_base, y_base, z_base)),
+        );
+    }
+    let seq_x = halton::Sequence::new(x_base);
+    let seq_y = halton::Sequence::new(y_base);
+    let seq_z = halton::Sequence::new(z_base);
+    YieldValues::Iter(seq_x.zip(seq_y).zip(seq_z).map(|((x, y), z)| (x, y, z)))
+}
+
+fn each_many(
+    rb_self: Value,
+    bases: &[Value],
+) -> Result<YieldSplat<impl Iterator<Item = RArray>>, Error> {
+    if bases.is_empty() {
+        return Err(Error::new(
+            exception::arg_error(),
+            "wrong number of arguments (given 0, expected 1+)",
+        ));
+    }
+    if !block_given() {
+        return Ok(YieldSplat::Enumerator(
+            rb_self.enumeratorize("each_many", bases),
+        ));
+    }
+    let mut seqs = bases
+        .iter()
+        .map(|v| v.try_convert().map(halton::Sequence::new))
+        .collect::<Result<Vec<_>, _>>()?;
+    let mut buffer = Vec::<Value>::with_capacity(seqs.len());
+    Ok(YieldSplat::Iter(std::iter::from_fn(move || {
+        buffer.clear();
+        for seq in &mut seqs {
+            if let Some(v) = seq.next() {
+                buffer.push(v.into());
+            } else {
+                return None;
+            }
+        }
+        Some(RArray::from_slice(&buffer))
+    })))
+}
+
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let module = define_module("Halton")?;
-    module.define_singleton_method("number", function!(halton::number, 2));
+    module.define_singleton_method("number", function!(halton::number, 2))?;
+    module.define_singleton_method("each_one", method!(each_one, 1))?;
+    module.define_singleton_method("each_pair", method!(each_pair, 2))?;
+    module.define_singleton_method("each_triple", method!(each_triple, 3))?;
+    module.define_singleton_method("each_many", method!(each_many, -1))?;
     let class = module.define_class("Sequence", Default::default())?;
-    class.define_singleton_method("new", function!(Sequence::new, 1));
-    class.define_method("next", method!(Sequence::next, 0));
-    class.define_method("skip", method!(Sequence::skip, 1));
-    class.define_method("remaining", method!(Sequence::remaining, 0));
+    class.define_singleton_method("new", function!(Sequence::new, 1))?;
+    class.define_method("next", method!(Sequence::next, 0))?;
+    class.define_method("skip", method!(Sequence::skip, 1))?;
+    class.define_method("remaining", method!(Sequence::remaining, 0))?;
     Ok(())
 }

data/lib/halton.rb

@@ -68,33 +68,17 @@ module Halton
   #
   # The numbers yielded will be in the range > 0 and < 1.
   #
-  def self.each(base, *bases)
-    return to_enum(__method__, base, *bases) unless block_given?
-
-    if bases.empty?
-      seq = Sequence.new(base)
-      loop {yield seq.next}
-      return nil
-    end
-
-    if bases.length == 1
-      x = Sequence.new(base)
-      y = Sequence.new(bases.first)
-      loop {yield x.next, y.next}
-      return nil
+  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
-
-    if bases.length == 2
-      x = Sequence.new(base)
-      y = Sequence.new(bases.first)
-      z = Sequence.new(bases.last)
-      loop {yield x.next, y.next, z.next}
-      return nil
-    end
-
-    seqs = bases.unshift(base).map {|b| Sequence.new(b)}
-    loop {yield(*seqs.map(&:next))}
-    nil
   end
 
   # Halton::Sequence implements the fast generation of Halton sequences.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: halton
 version: !ruby/object:Gem::Version
-  version: 0.2.1.2
+  version: 0.2.1.3
 platform: ruby
 authors:
 - Mat Sadler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-26 00:00:00.000000000 Z
+date: 2022-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake