datafarming 1.4.0 → 2.2.0

data/DESCRIPTIONS.md

@@ -1,45 +0,0 @@
-#### COMMAND-LINE TOOLS
-
-Ruby is a powerful and concise  object-oriented scripting language.  Scripts are normally 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`, `-h`, or `-?` option.  Quick descriptions follow.
-
-#### DATA MANIPULATION
-- `blank2csv.rb` —
-convert whitespace-delimited files to Comma Separated Values (CSV) files
-- `cat.rb` —
-Unix `cat` program work-alike for Windows—for viewing or creating text files or concatenating multiple files, based on stdio
-- `convert_line_endings.rb` —
-convert text files (including CSV files) to your current operating system environment (e.g., DOS to Unix or Unix to DOS)
-- `csv2blank.rb` —
-convert CSV files to whitespace-delimited files
-- `pool_files.rb` —
-pool columns from separate files into a new file, useful for combining design file & output files or multiple output files
-- `stripheaders.rb`, `stripheaderdups.rb` —
-remove column headers from a file, or duplicate headers within a file, respectively
-
-#### DESIGN GENERATORS
-- `augment_design.rb` —
-generate star points to augment an already existing factorial design
-- `cross.rb` —
-create a combinatorial design by crossing all combinations of any # of individual smaller designs
-- `scaled_fde.rb` —
-generate fully orthogonal quadratic designs based on discrete Fourier frequencies, with factor scaling
-- `scaled_rf_cubed.rb` —
-generate 2-level Resolution V fractional factorial designs and Central Composite Designs (CCDs), with factor scaling
-- `stack_nolhs.rb` —
-generate designs by reassigning columns from pre-tabled NOLHs, with factor scaling, for up to 100 factors
-
-#### RUN CONTROL
-  - `batchrunner.rb` —
-run a model interactively with replication
-  - `rundesign_general.rb` —
-run control to replicate a designed experiment applied to a model
-
-#### CONFIDENCE INTERVALS FOR TIME SERIES
-  - `mser.rb` —
-use MSER truncation to remove initial transient effects for time-series output, reporting truncated average and number of observations for each run to facilitate construction of a properly weighted confidence interval.
-  - `mser_nolbm.rb` —
-use MSER truncation to remove initial transient effects for time-series output, then calculate a 95% confidence interval on the remaining data using non-overlapping batch means.
-  - `mser_olbm.rb` —
-use MSER truncation to remove initial transient effects for time-series output, then calculate a 95% confidence interval on the remaining data using overlapping batch means.

data/exe/augment_design.rb

@@ -1,66 +0,0 @@
-#!/usr/bin/env ruby -w
-
-# This script generates star points to augment a fractional factorial
-# so you can check for quadratic effects.
-
-require 'colorize'
-
-String.disable_colorization false
-
-require 'optparse'
-require 'datafarming/error_handling'
-
-help_msg = [
-  'Generate star points to augment a fractional factorial ' \
-  'with quadratic effects.',
-  'Results are white-space delimited data written to ' +
-    'stdout'.light_blue + ', and can be redirected', 'as desired.', '',
-  'Syntax:',
-  "\n\t#{ErrorHandling.prog_name} [--help] FACTOR_INFO".yellow, '',
-  "Arguments in square brackets are optional.  A vertical bar '|'",
-  'indicates valid alternatives for invoking the option.  Prefix',
-  'the command with "' + 'ruby'.yellow +
-  '" if it is not on your PATH.', '',
-  '  --help | -h | -? | ?'.green,
-  "\tProduce this help message.",
-  '  FACTOR_INFO'.green,
-  "\tEITHER the number of factors (produces standardized +/-1 design),",
-  "\tOR pairs of values " + 'low1 hi1 low2 hi2...lowN hiN'.green +
-    ' for each of the',
-  "\tN factors.", ''
-]
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{$PROGRAM_NAME} [-h|--help] [number of factors]"
-  opts.on('-h', '-?', '--help') { ErrorHandling.clean_abort help_msg }
-end.parse!
-
-if ARGV.length == 0 || (ARGV[0] == '?') || (ARGV.length > 1 && ARGV.length.odd?)
-  ErrorHandling.clean_abort help_msg
-else
-  num_factors = 0
-  if ARGV.length == 1
-    num_factors = ARGV.shift.to_i
-    x = Array.new(num_factors, ' 0')
-    ranges = Array.new(2 * num_factors)
-    ranges.each_index { |i| ranges[i] = (i.even? ? '-1' : ' 1') }
-  else
-    num_factors = ARGV.length / 2
-    x = Array.new(num_factors)
-    ranges = ARGV
-    num_factors.times do |i|
-      x[i] = 0.5 * (ranges[2 * i].to_f + ranges[2 * i + 1].to_f)
-    end
-  end
-  # create and print an array at the global center point (0,0,...,0)
-  puts x.join(' ')
-
-  # now generate and print the star points at +/-1 along each factor axis
-  num_factors.times do |i|
-    y = x.clone
-    y[i] = ranges[2 * i]
-    puts y.join(' ')
-    y[i] = ranges[2 * i + 1]
-    puts y.join(' ')
-  end
-end

data/exe/scaled_fde.rb

@@ -1,169 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'colorize'
-String.disable_colorization false
-
-require 'datafarming/error_handling'
-require 'datafarming/freq_sets'
-
-help_msg = [
-  'Generate scaled FDE designs with shifting and stacking. The resulting',
-  'design is written to ' +
-    'stdout'.light_blue + '.', '',
-  'Syntax:',
-  "\n\t#{$PROGRAM_NAME.split(%r{/|\\})[-1]} [--help]".yellow +
-    " [-c] [-d #] [-e] [-k #] [-s #] [file_name]\n".yellow,
-  "Arguments in square brackets are optional.  A vertical bar '|'",
-  'indicates valid alternatives for invoking the option.  Prefix',
-  'the command with "' + 'ruby'.yellow +
-    '" if it is not on your PATH.', '',
-  '  --help | -h | -? | ?'.green,
-  "\tProduce this help message.  Supersedes any other choices.",
-  '  --csv | -c'.green,
-  "\tGenerate output as comma-separated-values.",
-  '  --num_factors # | -k #'.green,
-  "\tSpecify number of factors using standard (+/-1) scaling.",
-  '  --design # | -d #'.green,
-  "\tSpecify which design number you want.  Default is highest",
-  "\tfrequency set available for the target number of factors.",
-  "\tAn input larger than the available number will produce an",
-  "\terror message that identifies the allowable range.",
-  '  --stack # | -s #'.green,
-  "\t# specifies the number of stackings. The specified value cannot",
-  "\texceed the number of columns in the design being used. If this",
-  "\toption is omitted then only the base design is generated.",
-  '  --excel-style-input | -e'.green,
-  "\tSpecify factor ranges similarly to the NOLH spreadsheet, i.e.,",
-  "\tthe first line is the set of minimum range values for all factors,",
-  "\tand the second line is maximum range values.  Without this option,",
-  "\tthe default input format is one line per factor, comprised of the",
-  "\tmin and max separated by commas or whitespace.",
-  '  file_name'.green,
-  "\tThe name of a file containing the factor specifications.  If no",
-  "\tfilename is given, the user can enter the values interactively in",
-  "\tthe desired form or use file redirection with '<'.", '',
-  'Options may be given in any order, but must come before the file name',
-  'if one is provided.'
-]
-
-# Scaler objects will rescale a FDE design from standard units
-# to a range specified by min and max
-class Scaler
-  def initialize(min = -1, max = 1)
-    @mid = 0.5 * (max + min)
-    @amplitude = 0.5 * (max - min)
-  end
-
-  def scale(value)
-    @mid + @amplitude * value
-  end
-end
-
-def make_design(number_of_factors, design_num = -1)
-  design = Array.new(number_of_factors)
-  ds = FDE::DESIGN_SETS[number_of_factors]
-  freqs = ds.freqs[design_num].map { |f| Rational(f, ds.nyq) }
-  design.each_index do |column|
-    omega = freqs[column]
-    design[column] = Array.new(ds.nyq) do |i|
-      Math.sin(((i * omega) % 1) * FDE::TWO_PI)
-    end
-  end
-  design.transpose
-end
-
-excel_style_inputs = false
-csv_out = false
-design_num = -1
-num_stackings = 1
-n = nil
-while ARGV[0] && (ARGV[0][0] == '-' || ARGV[0][0] == 45 || ARGV[0][0] == '?')
-  current_value = ARGV.shift
-  case current_value
-  when '--csv', '-c'
-    csv_out = true
-  when '--design', '-d'
-    design_num = ARGV.shift.to_i - 1
-  when '--num_factors', '-k'
-    n = ARGV.shift.to_i
-  when '--stack', '-s'
-    num_stackings = ARGV.shift.to_i
-  when '--excel-style-input', '-e'
-    excel_style_inputs = true
-  when '--help', '-h', '-help', '-?', '?'
-    ErrorHandling.clean_abort help_msg
-  else
-    ErrorHandling.message ['Unknown argument: '.red + current_value.yellow]
-    ErrorHandling.clean_abort help_msg
-  end
-end
-
-if n
-  factor = Array.new(n) { Scaler.new }
-else
-  begin
-    if excel_style_inputs
-      if ARGF.filename == '-'
-        STDERR.puts  'Enter one line of min values, and one of max values.'.green
-      end
-      min_values = ARGF.gets.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_f)
-      max_values = ARGF.gets.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_f)
-    else
-      if ARGF.filename == '-'
-        STDERR.puts  'To terminate input enter '.green + 'ctrl-d'.cyan +
-                    ' (Mac/Unix/Linux)'.green + ' or '.green + 'ctrl-z'.cyan +
-                    ' (Windows).'.green
-        STDERR.puts  'Enter ranges for each factor on a separate line.'.green
-        STDERR.puts  "\nMIN\tMAX".cyan
-      end
-      min_values = []
-      max_values = []
-      while line = ARGF.gets
-        values = line.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_f)
-        min_values << values.shift
-        max_values << values.shift
-      end
-    end
-  rescue StandardError => e
-    ErrorHandling.message [e.message.red]
-    ErrorHandling.clean_abort help_msg
-  end
-
-  n = min_values.size
-  if max_values.size != n
-    ErrorHandling.message ['Unequal counts for min, max'.red]
-    ErrorHandling.clean_abort help_msg
-  end
-
-  factor = Array.new(n) do |i|
-    Scaler.new(min_values[i], max_values[i])
-  end
-end
-
-if design_num >= FDE::DESIGN_SETS[n].freqs.length
-  ErrorHandling.clean_abort [
-    "Design number cannot exceed #{FDE::DESIGN_SETS[n].freqs.length} for #{n} factors".red
-  ]
-end
-
-design = make_design(n, design_num)
-
-num_columns = design[0].length
-if num_stackings > num_columns
-  ErrorHandling.clean_abort [
-    'Requested stacking exceeds number of columns in FDE '.red +
-    "(#{num_columns})".red
-  ]
-end
-
-num_stackings.times do |_stack_num|
-  design.each_with_index do |dp, i|
-    scaled_dp = dp.slice(0, n).map.with_index { |x, k| factor[k].scale(x) }
-    if csv_out
-      puts scaled_dp.join ','
-    else
-      puts scaled_dp.join "\t"
-    end
-    design[i] = dp.rotate
-  end
-end

data/exe/scaled_rf_cubed.rb

@@ -1,173 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'colorize'
-String.disable_colorization false
-
-require_relative '../lib/datafarming/error_handling'
-require_relative '../lib/datafarming/factorial_generator'
-
-def print_descriptor
-  description = [
-    "\nCreate a Resolution V fractional factorial design, either in standard +/-1",
-    'notation or scaled as per user-provided input. The design can optionally ',
-    'be supplemented with CCD center and star points.  Output is written to',
-    'stdout'.blue + ' with formatting controlled by command-line options.'
-  ]
-  STDERR.puts description
-end
-
-def print_directions # :nodoc:
-  prog = $PROGRAM_NAME.split(/\//)[-1]
-  help_msg = [
-    '', 'Syntax:', '',
-    "  ruby #{prog} [Options] #factors | low/high-settings".yellow, '',
-    "The vertical bar '|' indicates valid alternatives.", '',
-    'Command-line args must specify either:',
-    '  - the number of factors for the design; or',
-    '  - low and hi values for all factors.', '',
-    "\nOptions:",
-    '  --help | -h | -? | ?'.green,
-    "\tProduce this help message.",
-    '  --design-only | -d'.green,
-    "\tprint the design without labeling",
-    '  --csv | -c'.green,
-    "\tprint the design as comma separated",
-    '  --center | -a'.green,
-    "\tadd global center pt to check linearity",
-    '  --star | -s'.green,
-    "\taugment with Central Composite Design pts (includes --center)",
-    '  --rotatable | -r'.green,
-    "\tscale a CCD design to be rotatable (includes --star)",
-    ''
-  ]
-  STDERR.puts help_msg
-end
-
-(print_descriptor && print_directions && exit) if ARGV.empty?
-begin
-  labels = true
-  csv = false
-  scaled = false
-  center = false
-  star = false
-  rotatable = false
-  fmt_size = '5'
-  fmt_type = 'd'
-
-  while ARGV[0] =~ /^(-\D|\?)/
-    arg = ARGV.shift
-    case arg
-    when '-c', '--csv'
-      csv = true
-    when '-d', '--design-only'
-      labels = false
-    when '-a', '--center'
-      center = true
-    when '-s', '--star'
-      star = true
-      center = true
-    when '-r', '--rotatable'
-      rotatable = true
-      star = true
-      center = true
-      fmt_size = '11.8'
-      fmt_type = 'f'
-    when '-h', '--help', '-?', '?'
-      print_descriptor
-      print_directions
-      exit
-    else
-      raise "Unknown option #{arg}"
-    end
-  end
-
-  if ARGV.empty?
-    raise 'Must specify a design size'
-  elsif ARGV.length == 1
-    n = ARGV.shift.to_i
-  elsif (ARGV.length & 1).nonzero? # Odd number of args remaining!
-    raise 'Number of levels is odd: low/hi values must occur in pairs'
-  else
-    n = ARGV.length / 2
-    scaled = true
-    unless rotatable
-      fmt_type = 's'
-      fmt_size = [ARGV.map(&:length).max + 1, fmt_size.to_i].max
-    end
-  end
-
-  my_design = make_design n
-  if rotatable && star
-    inverse_len = 1.0 / Math.sqrt(n)
-    my_design.each_with_index do |row, i|
-      my_design[i] = row.map { |elt| elt * inverse_len }
-    end
-  end
-  my_design += [Array.new(n, 0)] if center
-
-  if star
-    star_design = Array.new(2 * n)
-    star_design.each_index { |row| star_design[row] = Array.new(n, 0) }
-    n.times do |col|
-      row = 2 * col
-      star_design[row][col] = -1
-      star_design[row + 1][col] = 1
-    end
-    my_design += star_design
-  end
-
-  if scaled
-    temp = my_design.transpose
-    temp.each_with_index do |factor, idx|
-      factor.map! do |value|
-        case value
-        when -1
-          ARGV[2 * idx + 1]
-        when 1
-          ARGV[2 * idx]
-        when 0
-          begin
-            0.5 * (Float(ARGV[2 * idx + 1]) + Float(ARGV[2 * idx]))
-          rescue
-            raise 'All factors must be numeric for augmented designs.'
-          end
-        else
-          begin
-            lo = Float(ARGV[2 * idx])
-            hi = Float(ARGV[2 * idx + 1])
-            range = hi - lo
-            0.5 * (hi + lo + value * range)
-          rescue
-            raise 'All factors must be numeric for augmented designs.'
-          end
-        end
-      end
-    end
-    my_design = temp.transpose
-  end
-
-  if labels
-    if csv
-      print ' DP#'
-      n.times { |i| print ",X#{i + 1}" }
-    else
-      print '  DP#'
-      n.times { |i| printf " %#{fmt_size}s", "X#{i + 1}" }
-    end
-    puts
-  end
-
-  my_design.each_with_index do |design_point, row_number|
-    if csv
-      printf('%d,', row_number + 1) if labels
-      puts design_point.join(',')
-    else
-      printf('%5d', row_number + 1) if labels
-      design_point.each { |value| printf " %#{fmt_size}#{fmt_type}", value }
-      puts
-    end
-  end
-rescue StandardError => e
-  STDERR.print "\n", e.message, "\n"
-  print_directions
-end

data/exe/stack_nolhs.rb

@@ -1,174 +0,0 @@
-#!/usr/bin/env ruby -w
-
-require 'colorize'
-String.disable_colorization false
-
-require 'datafarming/error_handling'
-require 'datafarming/nolh_designs'
-
-help_msg = [
-  'Generate scaled Latin hypercube designs with shifting and stacking. ',
-  'Results are a white-space delimited NOLH design written to ' +
-    'stdout'.light_blue + '.', '',
-  'Syntax:',
-  "\n\t#{$PROGRAM_NAME.split(%r{/|\\})[-1]} [--help]".yellow +
-    " [--stack #] [--levels #] [-e] [file_name]\n".yellow,
-  "Arguments in square brackets are optional.  A vertical bar '|'",
-  'indicates valid alternatives for invoking the option.  Prefix',
-  'the command with "' + 'ruby'.yellow +
-  '" if it is not on your PATH.', '',
-  '  --help | -h | -? | ?'.green,
-  "\tProduce this help message.  Supersedes any other choices.",
-  '  --stack # | -s #'.green,
-  "\t# specifies the number of stackings. A value of 1 means print the",
-  "\tbase design.  If this option is not specified the number of stackings",
-  "\tdefaults to the number of columns in the design.  The specified value",
-  "\tcannot exceed the number of columns in the design being used.",
-  '  --levels # | -l #'.green,
-  "\t# specifies the desired number of levels in the NOLH (17, 33, 65, 129,",
-  "\t257, or 512).  Defaults to the smallest design which can accommodate the",
-  "\tnumber of factors if this option is not specified.",
-  '  --excel-style-input | -e'.green,
-  "\tSpecify factor ranges and decimals as in the NOLH spreadsheet, i.e.,",
-  "\tthe first line is the set of minimum range values for each factor;",
-  "\tthe second line is maximum range values; and the third is the number",
-  "\tof decimal places to use for the range scaling.  Without this option,",
-  "\tthe default input format is one line per factor, comprised of the min,",
-  "\tmax, and number of decimal places separated by commas or whitespace.",
-  '  file_name'.green,
-  "\tThe name of a file containing the factor specifications.  If no",
-  "\tfilename is given, the user can enter the values interactively in",
-  "\tthe desired form or use file redirection with '<'.", '',
-  'Options may be given in any order, but must come before the file name',
-  'if one is provided.'
-]
-
-# Scaler objects will rescale a Latin Hypercube design from standard units
-# to a range as specified by min, max, and num_decimals
-class Scaler
-  def initialize(min, max, num_decimals, lh_max = 17)
-    @min = min
-    @range = (max - min) / (lh_max - 1).to_r
-    @scale_factor = 10.to_r**num_decimals
-  end
-
-  def scale(value)
-    new_value = @min + @range * (value.to_r - 1.to_r)
-    if @scale_factor == 1
-      new_value.round
-    else
-      ((@scale_factor * new_value).round / @scale_factor).to_f
-    end
-  end
-end
-
-excel_style_inputs = false
-while ARGV[0] && (ARGV[0][0] == '-' || ARGV[0][0] == 45 || ARGV[0][0] == '?')
-  current_value = ARGV.shift
-  case current_value
-  when '--stack', '-s'
-    num_stackings = ARGV.shift.to_i
-  when '--levels', '-l'
-    lh_levels = ARGV.shift.to_i
-    unless NOLH::DESIGN_TABLE.keys.include?(lh_levels)
-      ErrorHandling.clean_abort [
-        "Invalid number of levels for Latin hypercube: #{lh_levels}".red,
-        'Use 17, 33, 65, 129, 257, or 512.'.yellow
-      ]
-    end
-  when '--excel-style-input', '-e'
-    excel_style_inputs = true
-  when '--help', '-h', '-help', '-?', '?'
-    ErrorHandling.clean_abort help_msg
-  else
-    ErrorHandling.message ['Unknown argument: '.red + current_value.yellow]
-    ErrorHandling.clean_abort help_msg
-  end
-end
-
-begin
-  if excel_style_inputs
-    if ARGV.empty?
-      STDERR.puts  'Enter one line of min values, one of max values,'.green +
-      ' and one of #decimals.'.green
-    end
-    min_values = ARGF.gets.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_f)
-    max_values = ARGF.gets.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_f)
-    decimals = ARGF.gets.strip.split(/\s*[,;:]\s*|\s+/).map(&:to_i)
-  else
-    if ARGV.empty?
-      STDERR.puts  'To terminate input enter '.green + 'ctrl-d'.cyan +
-        ' (Mac/Unix/Linux)'.green + ' or '.green + 'ctrl-z'.cyan +
-        ' (Windows).'.green
-      STDERR.puts  'Enter ranges for each factor on a separate line.'.green
-      STDERR.puts  "\nMIN\tMAX\t#DIGITS".cyan
-    end
-    min_values = []
-    max_values = []
-    decimals = []
-    while line = ARGF.gets
-      values = line.strip.split(/\s*[,;:]\s*|\s+/)
-      min_values << values.shift.to_f
-      max_values << values.shift.to_f
-      decimals << values.shift.to_i
-    end
-  end
-rescue StandardError => e
-  ErrorHandling.message [e.message.red]
-  ErrorHandling.clean_abort help_msg
-end
-
-n = min_values.size
-if max_values.size != n || decimals.size != n
-  ErrorHandling.message ['Unequal counts for min, max, and decimals'.red]
-  ErrorHandling.clean_abort help_msg
-end
-minimal_size = case min_values.size
-               when 1..7
-                 17
-               when 8..11
-                 33
-               when 12..16
-                 65
-               when 17..22
-                 129
-               when 23..29
-                 257
-               when 30..100
-                 512
-               else
-                 ErrorHandling.message ['invalid number of factors'.red]
-                 ErrorHandling.clean_abort help_msg
-               end
-
-lh_levels ||= minimal_size
-
-if lh_levels < minimal_size
-  ErrorHandling.clean_abort [
-    "Latin hypercube with #{lh_levels} levels is too small for #{n} factors.".red
-  ]
-end
-
-factor = Array.new(n) do |i|
-  Scaler.new(min_values[i], max_values[i], decimals[i], lh_levels)
-end
-
-design = NOLH::DESIGN_TABLE[lh_levels]
-
-num_columns = design[0].length
-num_stackings ||= num_columns
-if num_stackings > num_columns
-  ErrorHandling.clean_abort [
-    'Requested stacking exceeds number of columns in latin hypercube '.red +
-    "(#{num_columns})".red
-  ]
-end
-
-mid_range = lh_levels / 2
-num_stackings.times do |stack_num|
-  design.each_with_index do |dp, i|
-    scaled_dp = dp.slice(0, n).map.with_index { |x, k| factor[k].scale(x) }
-    puts scaled_dp.join "\t" unless stack_num > 0 && i == mid_range && lh_levels < 512
-    design[i] = dp.rotate
-  end
-end

data/lib/datafarming/factorial_generator.rb

@@ -1,49 +0,0 @@
-require 'fwt'
-
-# Generate a Resolution V Fractional Factorial design for the specified
-# number of factors.  The design is guaranteed to yield unconfounded
-# interactions for all pairs of factors.  The design uses standardized
-# notation, i.e., -1 represents a low setting and 1 represents a high
-# setting for each factor.
-#
-# *Arguments*::
-#   - +number_of_factors+ -> the number of factors in your design. Limit is 120.
-# *Returns*::
-#   - a two-dimensional array specifying the design, where each column
-#     corresponds to a factor and each row is a design point.
-#
-# Author:: Paul J Sanchez (mailto:pjs@alum.mit.edu)
-# Copyright:: Copyright (c) 2020 Paul J Sanchez
-# License:: MIT
-#
-INDEX = [1, 2, 4, 8, 15, 16, 32, 51, 64, 85, 106, 128, 150, 171,
-         219, 237, 247, 256, 279, 297, 455, 512, 537, 557, 594, 643, 803,
-         863, 998, 1024, 1051, 1070, 1112, 1169, 1333, 1345, 1620, 1866,
-         2048, 2076, 2085, 2185, 2372, 2456, 2618, 2800, 2873, 3127, 3284,
-         3483, 3557, 3763, 4096, 4125, 4135, 4174, 4435, 4459, 4469, 4497,
-         4752, 5255, 5732, 5804, 5915, 6100, 6369, 6907, 7069, 8192, 8263,
-         8351, 8422, 8458, 8571, 8750, 8858, 9124, 9314, 9500, 10_026,
-         10_455, 10_556, 11_778, 11_885, 11_984, 13_548, 14_007, 14_514,
-         14_965, 15_125, 15_554, 16_384, 16_457, 16_517, 16_609, 16_771,
-         16_853, 17_022, 17_453, 17_891, 18_073, 18_562, 18_980, 19_030,
-         19_932, 20_075, 20_745, 21_544, 22_633, 23_200, 24_167, 25_700,
-         26_360, 26_591, 26_776, 28_443, 28_905, 29_577, 32_705]
-POWER = [1, 2, 4, 8, 16, 16, 32, 64, 64, 128, 128, 128, 256, 256,
-         256, 256, 256, 256, 512, 512, 512, 512, 1024, 1024, 1024, 1024,
-         1024, 1024, 1024, 1024, 2048, 2048, 2048, 2048, 2048, 2048, 2048,
-         2048, 2048, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096, 4096,
-         4096, 4096, 4096, 4096, 4096, 8192, 8192, 8192, 8192, 8192, 8192,
-         8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192,
-         16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 16_384,
-         16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 16_384,
-         16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 16_384, 32_768,
-         32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768,
-         32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768,
-         32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768, 32_768,
-         32_768, 32_768, 32_768]
-
-def make_design(number_of_factors)
-  Array.new(number_of_factors) do |i|
-    Array.new(POWER[number_of_factors], 0).tap { |a| a[INDEX[i]] = 1 }.hadamard
-  end.transpose
-end