flex-cartesian 0.1.9 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b26211b52fac8e2a26ff5408d422e6ae328aefbd67d0a18ac07ef0404006c05
-  data.tar.gz: cf406e24632a26605b5002e91ddfdf63bddaeb0a361d2dbbab76f5514bfdec88
+  metadata.gz: 4b34c40aea1692a248f2f4ee506b8b7a5a66a8257f90b1f74a7613897f8047c4
+  data.tar.gz: 3fb4c691a65ebcda1f9606368f436ba1ebee56749dee9e27d04296884cfef26e
 SHA512:
-  metadata.gz: 2cb31e4b65dba494aeac390ad1baee384c5eca90aeb67363cb374db4ba0c1e4b4d4f4dc6acac088642a751e9d7d4ee996b98c99abf49fdc98c615981c5c12663
-  data.tar.gz: 2b9c27d532a24430cbd21508d91d02d2f29172d9069eab75a8af5c60a2fb25936ff014de5ffc6c5a7df29e08d07de1b7272aefb6edbc907f60a96ae1e1520236
+  metadata.gz: 455053108bada48ae9b224879069cfe6e43fca419391e194f5b90dbaece0523ab7810eb471e1768814c17bc61f4952171493fb5c38283473d7798039f6b8b8dd
+  data.tar.gz: 63ebb02a0fb22162b67d17caf483ab2abc3499e9d072ddec3749124e82856d4bfcf3106fbe53b84fd927fe3b36279cb1b2103d75064d4a1cf393ab2f72912f38

data/README.md

@@ -12,6 +12,8 @@
 
 ✅ Functions over Cartesian vectors are decoupled from dimensionality
 
+✅ Define conditions on Cartesian combinations using `s.cond(:set) { |v| v.dim1 > v.dim2 } }` syntax
+
 ✅ Calculate over named dimensions using `s.cartesian { |v| puts "#{v.dim1} and #{v.dim2}" }` syntax
 
 ✅ Add functions over dimensions using `s.add_function { |v| v.dim1 + v.dim2 }` syntax
@@ -42,7 +44,7 @@ gem install flex-cartesian-*.gem
 
 ## Usage
 
-```
+```ruby
 #!/usr/bin/ruby
 
 require 'flex-cartesian'
@@ -51,6 +53,9 @@ require 'flex-cartesian'
 
 # BASIC CONCEPTS
 
+# 1. Cartesian object is a set of combinations of values of dimansions.
+# 2. Dimensions always have names.
+
 puts "\nDefine named dimensions"
 example = {
   dim1: [1, 2],
@@ -69,6 +74,12 @@ end
 
 # ITERATION OVER CARTESIAN SPACE
 
+# 3. Iterator is dimensionality-agnostic, that is, has a vector syntax that hides dimensions under the hood.
+#    This keeps foundational code intact, and isolates modifications in the iterator body 'do_something'.
+# 4. For efficiency on VERY largse Cartesian spaces, there are
+#    a). lazy evaluation of each combination
+#    b). progress bar to track time-consuming calculations.
+
 puts "\nIterate over all Cartesian combinations and execute action (dimensionality-agnostic style)"
 s.cartesian { |v| do_something(v) }
 
@@ -85,6 +96,12 @@ s.cartesian(lazy: true).take(2).each { |v| do_something(v) }
 
 # FUNCTIONS ON CARTESIAN SPACE
 
+# 5. A function is a virtual dimension that is calculated based on a vector of base dimensions.
+#    You can think of a function as a scalar field defined on Cartesian space.
+# 6. Functions are printed as virtual dimensions in .output method.
+# 7. However, functions remains virtual construct, and their values can't be referenced by name
+#    (unlike regular dimensions). Also, functions do not add to .size of Cartesian space.
+
 puts "\nAdd function 'triple'"
 puts "Note: function is visualized in .output as a new dimension"
 s.add_function(:triple) { |v| v.dim1 * 3 + (v.dim3 ? 1: 0) }
@@ -97,6 +114,28 @@ s.remove_function(:test)
 
 
 
+# CONDITIONS ON CARTESIAN SPACE
+
+# 8. A condition is a logical restriction of allowed combitnations for Cartesian space.
+# 9. Using conditions, you can take a slice of Cartesian space.
+#    In particular, you can reflect semantical dependency of dimensional values.
+
+puts "Build Cartesian space that includes only odd values of 'dim1' dimension"
+s.cond(:set) { |v| v.dim1.odd? }
+puts "print all the conditions in format 'index | condition '"
+s.cond
+puts "Test the condition: print the updated Cartesian space"
+s.output
+puts "Test the condition: check the updated size of Cartesian space"
+puts "New size: #{s.size}"
+puts "Clear condition #0"
+s.cond(:unset, index: 0)
+puts "Clear all conditions"
+s.cond(:clear)
+puts "Restored size without conditions: #{s.size}"
+
+
+
 # PRINT
 
 puts "\nPrint Cartesian space as plain table, all functions included"
@@ -125,7 +164,7 @@ s.export('example.yaml', format: :yaml)
 # UTILITIES
 
 puts "\nGet number of Cartesian combinations"
-puts "Note: .size counts only dimenstions, it ignores functions"
+puts "Note: .size counts only dimensions, it ignores virtual constructs (functions, conditions, etc.)"
 puts "Total size of Cartesian space: #{s.size}"
 
 puts "\nPartially converting Cartesian space to array:"
@@ -278,6 +317,23 @@ Example:
 s.cartesian { |v| v.output(colorize: true, align: false) }
 ```
 
+---
+
+### Conditions on Cartesian Space
+cond(command = :print, # or :set, :unset, :clear
+     index: nil, # index of a conditions to unset
+     &block # defintiion of the condition to set
+     )
+Example:
+```ruby
+s.cond(:set) { |v| v.dim1 > v.dim3 }
+s.cond # defaults to s.cond(:print) and shows all the conditions in the form 'index | definition'
+s.cond(:unset, 0) # remove previously set condition
+s.cond(:clear) # remove all conditions, if any
+```
+
+
+
 ## License
 
 This project is licensed under the terms of the GNU General Public License v3.0.  

data/lib/flex-cartesian.rb

@@ -3,6 +3,7 @@ require 'progressbar'
 require 'colorize'
 require 'json'
 require 'yaml'
+require 'method_source'
 
 module FlexOutput
   def output(separator: " | ", colorize: false, align: true)
@@ -27,9 +28,30 @@ class FlexCartesian
 
   def initialize(dimensions = nil)
     @dimensions = dimensions
+    @conditions = []
     @derived = {}
   end
 
+  def cond(command = :print, index: nil, &block)
+    case command
+    when :set
+      raise ArgumentError, "Block required" unless block_given?
+      @conditions << block
+      self
+    when :unset
+      raise ArgumentError, "Index of the condition required" unless index
+      @conditions.delete_at(index)
+    when :clear 
+      @conditions.clear
+      self
+    when :print 
+      return if @conditions.empty?
+      @conditions.each_with_index { |cond, idx| puts "#{idx} | #{cond.source.gsub(/^.*?\s/, '')}" }
+    else
+      raise ArgumentError, "unknown condition command: #{command}"
+    end
+  end
+
   def add_function(name, &block)
     raise ArgumentError, "Block required" unless block_given?
     @derived[name.to_sym] = block
@@ -61,18 +83,26 @@ class FlexCartesian
       struct_instance.define_singleton_method(name) { block.call(struct_instance) }
     end
 
+  next if @conditions.any? { |cond| !cond.call(struct_instance) }
+
     yield struct_instance
   end
 end
 
-  def size(dims = nil)
-    dimensions = dims || @dimensions
-    return 0 unless dimensions.is_a?(Hash)
-
-    values = dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
-    return 0 if values.any?(&:empty?)
-
-    values.map(&:size).inject(1, :*)
+  def size
+    return 0 unless @dimensions.is_a?(Hash)
+    if @conditions.empty?
+      values = @dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
+      return 0 if values.any?(&:empty?)
+      values.map(&:size).inject(1, :*)
+    else
+      size = 0
+      cartesian do |v|
+        next if @conditions.any? { |cond| !cond.call(v) }
+        size += 1
+      end
+      size
+    end
   end
 
   def to_a(limit: nil)
@@ -84,11 +114,10 @@ end
     result
   end
 
-  def progress_each(dims = nil, lazy: false, title: "Processing")
-    total = size(dims)
-    bar = ProgressBar.create(title: title, total: total, format: '%t [%B] %p%% %e')
+  def progress_each(lazy: false, title: "Processing")
+    bar = ProgressBar.create(title: title, total: size, format: '%t [%B] %p%% %e')
 
-    cartesian(dims, lazy: lazy) do |v|
+    cartesian(@dimensions, lazy: lazy) do |v|
       yield v
       bar.increment
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flex-cartesian
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: '0.2'
 platform: ruby
 authors:
 - Yury Rassokhin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 2025-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -52,10 +52,24 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: 'Flexible and human-friendly Cartesian product enumerator for Ruby. Supports
-  functions on cartesian, dimensionality-agnostic/dimensionality-aware iterators,
-  named dimensions, tabular output, lazy/eager evaluation, progress bar, import from
-  JSON/YAML, and export to Markdown/CSV. Code example: https://github.com/Yuri-Rassokhin/flex-cartesian/blob/main/README.md#usage'
+  functions and conditions on cartesian, dimensionality-agnostic/dimensionality-aware
+  iterators, named dimensions, tabular output, lazy/eager evaluation, progress bar,
+  import from JSON/YAML, and export to Markdown/CSV. Code example: https://github.com/Yuri-Rassokhin/flex-cartesian/blob/main/README.md#usage'
 email:
 - yuri.rassokhin@gmail.com
 executables: []