datafarming 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 420d0eef5a4e09793bbbcaea21a57047eb96ffa44aa28a96455d6d695002f556
-  data.tar.gz: 9e6dba22e9c9734c6da2555d01d4d2ed4f7fa5f0876badacb155c6a8a8fd542f
+  metadata.gz: 8d7589dc50c37a95f61fcd663202a51b54f5dcab18b40f06fd82a7ca6335a0ae
+  data.tar.gz: be600740132b28b59ee3b0b11b45dffaa630023b2babc884bb732efdb0757d49
 SHA512:
-  metadata.gz: 1849ba07886a55ed337fd699b62075de26a2050756d2f5a6a00394efb1e4ca4098a488336a8e0071a766793ece844f518adc777e9783f061da760f949f6b58f7
-  data.tar.gz: 60eaa33d6d9d66f2fa12e4d7bce18f8c67ccffdce26964064ec414a2f68e11e9fff76c649b446436f25c29768848f8b53b11ea79d516727fd31469009d893253
+  metadata.gz: 7d734fadf28fdef038fbb3f4cc9ee0b0d836d0c388345a005ecd3d9609396b411e527e7f408832a69dade7414ae01c1d016fc16a475be9b6a91045390c88fa44
+  data.tar.gz: 51122d843649187c2e335244b532d1df783fb100c5f0588f9965e604d1570a4cd036b44694590d1368087e13f2eff4649261803d23943512ca9c8032a1afae7b

data/LICENSE.md

@@ -1,7 +1,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Paul J. Sanchez
+Copyright (c) 2017-2024 Paul J. Sanchez
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -21,3 +21,5 @@ Gem installation only needs to be done once.  If you explicitly downloaded the `
 Ruby is a powerful and concise object-oriented scripting language.  Normally, Ruby scripts are run from a command-line or terminal environment by typing the `ruby` command followed by a script name, often followed by one or more command-line arguments.  However, scripts installed as gems do not need the `ruby` command to be typed explicitly.  For example, typing `stripheaderdups.rb my_file.txt` will invoke the `stripheaderdups.rb` script and apply it to file `my_file.txt` in your current working directory.  Note that on Windows the `.rb` suffix is not needed to run your scripts, e.g., `stripheaderdups my_file.txt` will suffice.
 
 All scripts in this distribution are self documenting if run with a `--help`, or `-h` option. You can run the command `datafarming.rb` at any point after installing this gem to see descriptions of the various data farming utilities included in thie distribution.
+
+After installing the gem and making sure that gems are on your PATH, run the command `datafarming.rb` for a summary/overview of the various data farming tools.

data/exe/generate_design.rb

@@ -62,15 +62,15 @@ EXAMPLES = [
   "  by whitespace.",
   '',
   'EXAMPLE 3:',
-  "\n  #{File.basename($PROGRAM_NAME)} -d nolh -k 5 --output_yaml > my_template.yaml",
+  "\n  #{File.basename($PROGRAM_NAME)} -d nolh -k 5 --output_yaml > my_template.yml",
   "\n  Generate a YAML template for a 5-factor NOLH design, and redirect it",
-  "  to the file 'my_template.yaml'. (The output file can be given any name",
+  "  to the file 'my_template.yml'. (The output file can be given any name",
   '  of your choosing.) The resulting YAML file has an intuitive human',
   "  readable format. It can be edited using your favorite programmer's",
   '  text editor (NOTE: word processors will not work!). After saving your',
   '  revisions, you can read it back in to generate the actual design using',
   "  the '--input_yaml' option:\n",
-  "  #{File.basename($PROGRAM_NAME)} --input_yaml < my_template.yaml",
+  "  #{File.basename($PROGRAM_NAME)} --input_yaml my_template.yml",
   ' '
 ].freeze
 
@@ -91,34 +91,40 @@ def examples(opts)
   exit
 end
 
+def fatal_err(msg)
+  STDERR.puts msg
+  exit 1
+end
+
 def resv(options)
   require 'datafarming/res_v_seqs'
-  raise 'Too many factors for ResV designs' if options[:num_factors] > RESV::INDEX.size
-
-  RESV.make_design options[:num_factors]
+  num_factors = options[:specs].size
+  fatal_err("Too many factors for ResV designs") if num_factors > RESV::INDEX.size
+  RESV.make_design num_factors
 end
 
 def ccd(options)
   require 'datafarming/res_v_seqs'
-  raise 'Too many factors for CCD designs' if options[:num_factors] > RESV::INDEX.size
-
-  RESV.make_design(options[:num_factors]) + RESV.star_pts(options[:num_factors])
+  num_factors = options[:specs].size
+  fatal_err("Too many factors for CCD designs") if num_factors > RESV::INDEX.size
+  RESV.make_design(num_factors) + RESV.star_pts(num_factors)
 end
 
 def rotatable(options)
   require 'datafarming/res_v_seqs'
-  raise 'Too many factors for Rotatable designs' if options[:num_factors] > RESV::INDEX.size
-
-  inv_len = 1.0 / Math.sqrt(options[:num_factors])
-  RESV.make_design(options[:num_factors]).each do |line|
+  num_factors = options[:specs].size
+  fatal_err("Too many factors for Rotatable designs") if num_factors > RESV::INDEX.size
+  inv_len = 1.0 / Math.sqrt(num_factors)
+  RESV.make_design(num_factors).each do |line|
     line.map! { |value| value * inv_len }
-  end + RESV.star_pts(options[:num_factors])
+  end + RESV.star_pts(num_factors)
 end
 
 def nolh(options)
   require 'datafarming/nolh_designs'
+  num_factors = options[:specs].size
   minimal_size =
-    case options[:num_factors]
+    case num_factors
     when 1..7
       17
     when 8..11
@@ -132,32 +138,28 @@ def nolh(options)
     when 30..100
       512
     else
-      raise "invalid number of factors: #{options[:num_factors]}"
+      fatal_err "invalid number of factors: #{num_factors}"
     end
-
   options[:levels] ||= minimal_size
-  if options[:levels] < minimal_size
-    raise "Latin hypercube with #{options[:levels]} levels is" \
-          "too small for #{options[:num_factors]} factors."
-  end
-
+  fatal_err("Latin hypercube with #{options[:levels]} levels is " \
+          "too small for #{num_factors} factors.") if options[:levels] < minimal_size
   NOLH::DESIGN_TABLE[options[:levels]]
 end
 
 def freqs2cols(options, design_set)
-  raise "No design (yet) for #{options[:num_factors]} factors" unless
-    design_set.key? options[:num_factors]
-
-  design_num = -1 # the last one has largest min frequency
-
-  ds = design_set[options[:num_factors]]
+  num_factors = options[:specs].size
+  fatal_err("No design (yet) for #{num_factors} factors") unless design_set.key? num_factors
+  design_num = 0 # most have only one design after removing isomorphisms
+  ds = design_set[num_factors]
   freqs = ds.freqs[design_num]
   Array.new(freqs.size) do |row|
     omega = freqs[row]
-    Array.new(ds.nyq) do |i|
+    v = Array.new(ds.nyq) do |i|
       f = ((i * omega) % ds.nyq).to_f / ds.nyq
       Math.sin(f * TWO_PI)
     end
+    scale_factor = v.max
+    v.map { |x| (x / scale_factor).round(15) }
   end.transpose
 end
 
@@ -174,17 +176,15 @@ end
 def validate_opts(options)
   required_options = [:design]
   missing = required_options - options.keys
-  raise "Missing required options: #{missing}" unless missing.empty?
-
+  fatal_err("Missing required options: --#{missing.join(', --')}") unless missing.empty?
   options[:design] = options[:design].to_sym
 end
 
 def validate(spec)
   unknown = spec.keys - REQUIRED_SPECS - ELECTIVE_SPECS
-  raise "Unknown factor spec(s): #{unknown}" unless unknown.empty?
-
+  fatal_err("Unknown factor spec(s): #{unknown}") unless unknown.empty?
   missing = REQUIRED_SPECS - spec.keys
-  raise "Factor spec #{spec} missing #{missing}" unless missing.empty?
+  fatal_err("Factor spec #{spec} missing #{missing}") unless missing.empty?
 end
 
 def optional_specs(factor_spec, i)
@@ -199,64 +199,89 @@ end
 
 def parse_specs(options, remainder)
   if remainder.size.positive?
-    options[:num_factors] = remainder.size
-    remainder.map.with_index { |factor_spec, i| optional_specs(factor_spec, i) }
-  elsif options.key? :num_factors
-    Array.new(options[:num_factors]) do |i|
-      { "id": "X_#{format('%03d', (i + 1))}", "min": -1, "max": 1, "decimals": nil }
+    remainder.each.with_index do |factor_spec, i|
+      options[:specs] << optional_specs(factor_spec, i)
     end
-  else
-    y_options, factor_specs = YAML.safe_load($stdin, permitted_classes: [Symbol])
-    y_options.each_key { |key| options[key] ||= y_options[key] }
-    factor_specs.each { |spec| validate(spec) }
   end
 end
 
 def parse_args
-  options = {
+  default_options = {
     headers: true,
     replicate: 1,
     stack: 1,
-    center: false
+    center: false,
+    specs: []
   }
 
-  remainder = OptionParser.new do |opts|
-    opts.banner = HELP_MSG.join("\n")
-    opts.on('-h', '--help', 'Prints help') { prog_help(opts) }
-    opts.on('-v', '--verbose-help', 'Print more verbose help') { verbose(opts) }
-    opts.on('-x', '--examples', 'Show some examples') { examples(opts) }
-    opts.on('-d', '--design=TYPE', DESIGN_TYPES,
-            'REQUIRED: Type of design, one of:',
-            "  #{DESIGN_TYPES.join ' '}")
-    opts.on('-k', '--num_factors=QTY', /[1-9][0-9]*/, Integer,
-            'Number of factors',
-            'Ignored if optional factor specs provided')
-    opts.on('-r', '--replicate=QTY', /[1-9][0-9]*/, Integer,
-            'Replicate QTY times', '(default: 1)')
-    opts.on('-s', '--stack=QTY', /[1-9][0-9]*/, Integer,
-            'Stack QTY times', '(default: 1)')
-    opts.on('--[no-]center', 'NOTE: Applies only to stacked designs',
-            'Stacking includes center pt','(default: no-center)')
-    opts.on('--[no-]headers', 'Output has column headers', '(default: headers)')
-    opts.on('-l', '--levels=QTY', Regexp.new("(#{LEVELS.join(')|(')})"),
-            Integer, 'NOTE: Applies only to NOLH designs',
-            'Number of levels in the base NOLH:',
-            "  #{LEVELS.join ' '}")
-    opts.on('-o', '--output_yaml', 'Write design YAML to STDOUT')
-    opts.on('-i', '--input_yaml', 'Read design YAML from STDIN')
-  end.parse!(into: options)
-
-  raise 'Optional factor specs ignored when using YAML input' if options[:input_yaml] && remainder.size.positive?
-
-  specs = parse_specs(options, remainder)
+  yaml_input = false
+  if ARGV.size > 2 && ARGV.any? { |elt| elt.eql?("-i") || elt.eql?("--input_yaml") }
+    STDERR.puts 'NOTE: All other arguments ignored when using YAML input'
+  end
+
+  options = default_options
+
+  begin
+    remainder = OptionParser.new do |opts|
+      opts.banner = HELP_MSG.join("\n")
+      opts.on('-h', '--help', 'Prints help') { prog_help(opts) }
+      opts.on('-v', '--verbose-help', 'Print more verbose help') { verbose(opts) }
+      opts.on('-x', '--examples', 'Show some examples') { examples(opts) }
+      opts.on('-d', '--design TYPE', DESIGN_TYPES,
+              'REQUIRED: Type of design, one of:',
+              "  #{DESIGN_TYPES.join ' '}")
+      opts.on('-k', '--num_factors QTY', /[1-9][0-9]*/, Integer,
+              'Number of factors',
+              'Ignored if optional factor specs provided') do |k|
+        options[:specs] = Array.new(k) do |i|
+          {id: "X_#{format('%03d', (i + 1))}", :min => -1, :max => 1 }
+        end
+        k
+      end
+      opts.on('-r', '--replicate QTY', /[1-9][0-9]*/, Integer,
+              'Replicate QTY times', '(default: 1)')
+      opts.on('-s', '--stack QTY', /[1-9][0-9]*/, Integer,
+              'Stack QTY times', '(default: 1)')
+      opts.on('--[no-]center', 'NOTE: Applies only to stacked designs',
+              'Stacking includes center pt','(default: no-center)')
+      opts.on('--[no-]headers', 'Output has column headers', '(default: headers)')
+      opts.on('-l', '--levels QTY', Regexp.new("(#{LEVELS.join(')|(')})"),
+              Integer, 'NOTE: Applies only to NOLH designs',
+              'Number of levels in the base NOLH:',
+              "  #{LEVELS.join ' '}")
+      opts.on('-o', '--output_yaml', 'Write design YAML to STDOUT')
+      opts.on("-i PATH", "--input_yaml", 'Read design YAML from PATH',
+              'Mutually exclusive with all other options, prints',
+              'warning to STDERR if other options are passed') do |path|
+        ARGV.clear
+        options = {specs: []}
+        yaml_input = true
+        YAML::safe_load_file(path, permitted_classes: [Symbol]).each do |k, v|
+          options.merge!({k.to_sym => v})
+        end
+      end
+    end.parse!(into: options)
+  rescue OptionParser::ParseError => error
+    fatal_err("#{error}\n(-h or --help will show valid options)")
+  end
+
+  fatal_err("Levels option only valid for NOLH designs") if options[:levels] && options[:design] != :nolh
+
+  remainder = [] if yaml_input
+  if remainder.size.positive? && options[:specs].size.positive?
+    STDERR.puts 'NOTE: Num_factors ignored when using optional factor specs'
+    options[:specs] = []
+  end
+  options.delete(:num_factors) if options.include?(:num_factors)
+
+  parse_specs(options, remainder)
   validate_opts options
-  [options, specs]
+  options
 end
 
 def stack(design, num_stacks, centered)
   return design if num_stacks < 2
-  raise "Stacking #{num_stacks} times exceeds number of design columns" if num_stacks > design[0].length
-
+  fatal_err("Stacking #{num_stacks} times exceeds number of design columns") if num_stacks > design[0].length
   num_stacks -= 1
   result = design.transpose
   if num_stacks > 0
@@ -273,25 +298,24 @@ def stack(design, num_stacks, centered)
   result.transpose
 end
 
-
 ARGV << '--help' if ARGV.empty?
 
-options, specs = parse_args
+options = parse_args
 
 if options[:output_yaml]
   options.delete :output_yaml
-  puts [options, specs].to_yaml
+  puts options.to_yaml
 else
   base_design = method(options[:design]).call(options)
   separator = ','
-  puts Array.new(options[:num_factors]) { |i| specs[i][:id] }.join(separator) if options[:headers]
+  puts Array.new(options[:specs].size) { |i| options[:specs][i][:id] }.join(separator) if options[:headers]
 
   # stack
   design = stack(base_design, options[:stack], options[:center])
-           .transpose.first(options[:num_factors]).transpose
+           .transpose.first(options[:specs].size).transpose
 
   # scale
-  scaler = specs.map do |spec|
+  scaler = options[:specs].map do |spec|
     Scaler.new(min: spec[:min], max: spec[:max], decimals: spec[:decimals])
   end