RubyGems - numru-misc - Versions diffs - 0.1.1 - Mend

numru-misc 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

data/ChangeLog +41 -0
data/LICENSE.txt +34 -0
data/Rakefile +38 -0
data/doc/emath.html +26 -0
data/doc/index.html +83 -0
data/doc/keywordopt.html +179 -0
data/doc/md_iterators.html +86 -0
data/doc/misc.html +83 -0
data/install.rb +104 -0
data/lib/numru/misc.rb +4 -0
data/lib/numru/misc/emath.rb +75 -0
data/lib/numru/misc/keywordopt.rb +498 -0
data/lib/numru/misc/md_iterators.rb +180 -0
data/lib/numru/misc/misc.rb +196 -0
data/makedoc.csh +6 -0
metadata +97 -0

data/doc/misc.html ADDED

@@ -0,0 +1,83 @@
+<?xml version="1.0" ?>
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>lib/numru/misc/misc.rb</title>
+</head>
+<body>
+<h1><a name="label:0" id="label:0">module NumRu::Misc</a></h1><!-- RDLabel: "module NumRu::Misc" -->
+<h2><a name="label:1" id="label:1">Overview</a></h2><!-- RDLabel: "Overview" -->
+<p>Miscellaneous functions and classes to facilitate programming.</p>
+<h2><a name="label:2" id="label:2">Index</a></h2><!-- RDLabel: "Index" -->
+<p>CLASSES</p>
+<ul>
+<li><a href="keywordopt.html">class KeywordOpt</a>
+  to support keyward arguments with default values.</li>
+<li><a href="narray_ext.html">class NArray (enhancement of NArray made by M Tanaka)</a></li>
+</ul>
+<p>MODULES</p>
+<ul>
+<li><a href="md_iterators.html">module MD_Iterators</a> A Mixin for classes with
+  multi-dimension indexing support (such as NArray).</li>
+<li><a href="emath.html">module EMath</a>
+  To be included instead of the Math predefined module (or NMath in NArray).
+  Unlike Math and NMath, EMath handles unknown classes by calling its
+  native instance method (assuming the same name).</li>
+</ul>
+<p>MODULE FUNCTIONS</p>
+<ul>
+<li><a href="#label:4">check_shape_consistency</a></li>
+</ul>
+<h2><a name="label:3" id="label:3">Module functions</a></h2><!-- RDLabel: "Module functions" -->
+<dl>
+<dt><a name="label:4" id="label:4"><code>check_shape_consistency(<var>cshapes</var>, *<var>args</var>)</code></a></dt><!-- RDLabel: "check_shape_consistency" -->
+<dd>
+<p>Check the consistency of array shapes (multi-dim such as NArray).
+Exception is raised if inconsistent.</p>
+<p>ARGUMENTS</p>
+<ul>
+<li>cshapes (String) : description of the shapes of the args.
+       Delimited by one-or-more spaces between arrays,
+       and the shape of each array is delimited by a comma. The lengths are
+       expressed with string names as identifiers (in that case, length
+       values are unquestioned) or specified as positive integers.
+       Use '..' or '...' for repetition of the last shape.
+       See EXAMPLES below.</li>
+<li>args (multi-dim arrays such as NArray): arrays to be checked</li>
+</ul>
+<p>RETURN VALUE</p>
+<ul>
+<li>nil</li>
+</ul>
+<p>POSSIBLE EXCEPTIONS</p>
+<ul>
+<li>exception is raised if cshapes and args are inconsistent:
+<ul>
+<li>RuntimeError, if the arrays do not have shapes specified by cshapes.</li>
+<li>ArgeumentError, if the number of args are inconsistent with cshapes.
+         This is likely a coding error of the user.</li>
+</ul></li>
+</ul>
+<p>EXAMPLES</p>
+<ul>
+<li><p>to check whether three arrays u, v, and w are shaped as
+        u[nx], v[ny], and w[nx,ny], where nx and ny are any integer:</p>
+<pre>NumRu::Misc.check_shape_consistency('nx ny nx,ny',u,v,w)</pre>
+<p>Or equivalently,</p>
+<pre>NumRu::Misc.check_shape_consistency('m  n  m,n',u,v,w)</pre>
+<p>because actual strings does not matter.</p></li>
+<li><p>To specify fixed lengths, use integers instead of names:</p>
+<pre>NumRu::Misc.check_shape_consistency('4  n  4,n',u,v,w)</pre>
+<p>In this case, u,v,w must have shapes [4], [ny], and [4,ny],
+where ny is any length.</p></li>
+<li><p>Use '..' or '...' to repeat the same shape:</p>
+<pre>NumRu::Misc.check_shape_consistency('nx,ny ...',u,v,w)</pre>
+<p>This ensures that u, v, and w are 2D arrays with the same shape.
+Note: '..' and '...' are the same, so you can use whichever you like.</p></li>
+</ul></dd>
+</dl>
+</body>
+</html>

data/install.rb ADDED

@@ -0,0 +1,104 @@
+require 'rbconfig'
+require 'find'
+include Config
+if CONFIG["MINOR"].to_i > 6 then $rb_18 = true else $rb_18 = false end
+if $rb_18
+  require 'fileutils'
+else
+  require 'ftools'
+end
+=begin
+$version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+$libdir = File.join(CONFIG["libdir"], "ruby", $version)
+# $archdir = File.join($libdir, CONFIG["arch"])
+$site_libdir = $:.find {|x| x =~ /site_ruby$/}
+if !$site_libdir
+  $site_libdir = File.join($libdir, "site_ruby")
+elsif Regexp.compile($site_libdir) !~ Regexp.quote($version)
+  $site_libdir = File.join($site_libdir, $version)
+end
+default_destdir = $site_libdir
+=end
+default_destdir = CONFIG["sitelibdir"]
+def install_rb(srcdir, destdir)
+  libdir = "lib"
+  libdir = File.join(srcdir, libdir) if srcdir
+  path = []
+  dir = []
+  Find.find(libdir) do |f|
+    next unless FileTest.file?(f)
+    next if (f = f[libdir.length+1..-1]) == nil
+    next if (/CVS$/ =~ File.dirname(f))
+    path.push f
+    dir |= [File.dirname(f)]
+  end
+  for f in dir
+    next if f == "."
+    next if f == "CVS"
+    if $rb_18
+      FileUtils.makedirs(File.join(destdir, f))
+    else
+      File::makedirs(File.join(destdir, f))
+    end
+  end
+  for f in path
+    next if (/\~$/ =~ f)
+    next if (/^\./ =~ File.basename(f))
+    if $rb_18
+      FileUtils.install(File.join("lib", f), File.join(destdir, f), {:mode => 0644, :verbose => true})
+    else
+      File::install(File.join("lib", f), File.join(destdir, f), 0644, true)
+    end
+  end
+end
+def ARGV.switch
+  return nil if self.empty?
+  arg = self.shift
+  return nil if arg == '--'
+  if arg =~ /^-(.)(.*)/
+    return arg if $1 == '-'
+    raise 'unknown switch "-"' if $2.index('-')
+    self.unshift "-#{$2}" if $2.size > 0
+    "-#{$1}"
+  else
+    self.unshift arg
+    nil
+  end
+end
+def ARGV.req_arg
+  self.shift || raise('missing argument')
+end
+destdir = default_destdir
+begin
+  while switch = ARGV.switch
+    case switch
+    when '-d', '--destdir'
+      destdir = ARGV.req_arg
+#    when '-u', '--uninstall'
+#      uninstall = true
+    else
+      raise "unknown switch #{switch.dump}"
+    end
+  end
+rescue
+  STDERR.puts $!.to_s
+  STDERR.puts File.basename($0) +
+    " -d <destdir>"
+  exit 1
+end
+#if( defined?(uninstall) && uninstall )
+#   uninstall_rb(nil, destdir)
+#else
+   install_rb(nil, destdir)
+#end

data/lib/numru/misc.rb ADDED

@@ -0,0 +1,4 @@
+require 'numru/misc/misc'
+require 'numru/misc/keywordopt'
+require 'numru/misc/md_iterators'
+require 'numru/misc/emath'

data/lib/numru/misc/emath.rb ADDED

@@ -0,0 +1,75 @@
+=begin
+=module NumRu::Misc::EMath
+To be included instead of the Math predefined module (or NMath in NArray).
+Unlike Math and NMath, EMath handles unknown classes by calling its
+native instance method (assuming the same name).
+Therefore, if included, its function (module method) is used as:
+   cos( obj )
+and so on. If obj is not of a supported class, EMath calls, obj.cos in
+this case.  (If cos is not a method of obj, then an exception is
+raised.)  Supported classes are Numeric (by Math) and NArray (by
+NMath).  EMath stands for "good Math" (for obvious reason for a
+Japanese).
+Note: as for atan2(a,b), a.atan2(b) will be called if a or b
+is not supported. This is the case for all functions that take
+two or more arguments.
+=end
+require "narray"
+module NumRu
+  module Misc
+    module EMath
+      E = Math::E
+      PI = Math::PI
+      funcs = ["acos", "acosh", "asin", "asinh", "atan", "atan2", "atanh",
+               "cos", "cosh", "erf", "erfc", "exp", "frexp", "hypot",
+               "ldexp", "log", "log10", "sin", "sinh", "sqrt", "tan", "tanh"]
+               # FUNCS: from ruby 1.8.0, ( Math.methods - Object.methods ).sort
+      module_function
+      funcs.each{|func|
+	eval <<-EOS,nil,__FILE__,__LINE__+1
+	def #{func}(*arg)
+          case arg[0]
+          when Numeric
+	    Math.#{func}(*arg)
+	  when NArray
+	    NMath.#{func}(*arg)
+	  else
+	    obj = arg.shift
+	    begin
+	      obj.#{func}(*arg)
+	    rescue NameError
+	      raise TypeError,"cannot handle \#{obj.class}: \#{obj.inspect}"
+	    end
+	  end
+	end
+	EOS
+      }
+    end
+  end
+end
+if __FILE__ == $0
+  include NumRu::Misc::EMath
+  p cos( PI )
+  p cos( Complex(0, 1) )
+  p cos( NArray[0,PI/3,PI/2] )
+  begin
+    p cos( "ggg" )
+  rescue
+    print "* error as expected >>: ",$!,"\n"
+  end
+  require 'narray_miss'
+  nam = NArrayMiss.to_nam( NArray[0,PI/3,PI/2] )
+  p cos(nam)
+end

data/lib/numru/misc/keywordopt.rb ADDED

@@ -0,0 +1,498 @@
+=begin
+==Index
+* ((<class NumRu::Misc::KeywordOpt>))
+* ((<class NumRu::Misc::KeywordOptAutoHelp < NumRu::Misc::KeywordOpt>))
+= class NumRu::Misc::KeywordOpt
+== Overview
+A class to facilitate optional keyword arguments. More specifically,
+it helps the use of a Hash to mimic the keyword argument system.
+With this, you can set default values and description to each
+keyword argument.
+== Classes defined supplementarilly
+=== class NumRu::Misc::HelpMessagingException < StandardError
+This is for your convenience. See the usage example below.
+== Usage example
+Suppose that you introduce keyword arguments "flag" and "number"
+to the method "hoge" in a class/module Foo. It can be done as
+follows:
+  require 'numru/misc'  # or, specifically, require 'numru/misc/keywordopt'
+  include NumRu
+  class Foo
+    @@opt_hoge = Misc::KeywordOpt.new(
+      ['flag',   false, 'whether or not ...'],
+      ['number', 1,     'number of ...'],
+      ['help',   false, 'show help message']
+    )
+    def hoge(regular_arg1, regular_arg2, options=nil)
+      opt = @@opt_hoge.interpret(options)
+      if opt['help']
+        puts @@opt_hoge.help
+        puts ' Current values='+opt.inspect
+        raise Misc::HelpMessagingException, '** show help message and raise **'
+      end
+      # do what you want below
+      # (options are set in the Hash opt: opt['flag'] and opt['number'])
+    end
+  end
+Here, the options are defined in the class variable @@opt_hoge
+with option names, default values, and descriptions (for help
+messaging). One can use the method hoge as follows:
+  foo = Foo.new
+  ...
+  x = ...
+  y = ...
+  ...
+  foo.hoge( x, y, {'flag'=>true, 'number'=>10} )
+Or equivalently,
+  foo.hoge( x, y, 'flag'=>true, 'number'=>10 )
+because '{}' can be omitted here.
+Tails of options names can be shortened as long as unambiguous:
+  foo.hoge( x, y, 'fla'=>true, 'num'=>10 )
+To show the help message, call
+  foo.hoge( x, y, 'help'=>true )
+This will cause the following help message printed with the
+exception HelpMessagingException raised.
+   << Description of options >>
+    option name => default value   description:
+     "flag" =>     false   whether or not ...
+     "number" =>   1       number of ...
+     "help" =>     false   show help message
+   Current values={"help"=>true, "number"=>1, "flag"=>false}
+   NumRu::Misc::HelpMessagingException: ** help messaging done **
+          from (irb):78:in "hoge"
+          from (irb):83
+Do not affraid to write long descriptions. The help method
+breaks lines nicely if they are long.
+== Class methods
+---KeywordOpt.new( *args )
+    Constructor.
+    ARGUMENTS
+    * args : (case 1) arrays of two or three elements: [option name,
+      default value, description ], or [option name, default value]
+      if you do not want to write descriptions. Option names and
+      descriptions must be String. (case 2) another KeywordOpt.
+      Cases 1 and 2 can be mixed.
+      When case 2, a link to the other KeywordOpt is kept. Thus, change
+      of values in it is reflected to the current one. However,
+      the link is deleted if values are changed by ((<set>)).
+    RETURN VALUE
+    * a KeywordOpt object
+    EXAMPLE
+    * case 1
+	opt = Misc::KeywordOpt.new(
+	  ['flag',   false, 'whether or not ...'],
+	  ['help',   false, 'show help message']
+	)
+    * case 2
+        opt = Misc::KeywordOpt.new( optA, optB )
+    * case 1 & 2
+	opt = Misc::KeywordOpt.new(
+	  ['flag',   false, 'whether or not ...'],
+	  optA
+	)
+== Methods
+---interpret(hash)
+    Interprets a hash that specifies option values.
+    ARGUMENTS
+    * hash (Hash or nil) : a hash with string keys matching option names
+      (initializedwhen constructed). The matching is case sensitive and done
+      such that the tail of a option name can be omitted as long as
+      unambiguous (for example, 'num' for 'number').
+      If the argument is nil, the current values are returned.
+      If there are two options like 'max' and 'maxval', to use
+      a key 'max' (identical to the former paramer) is allowed, although
+      it matches 'maxval' as well. (Again 'ma' is regarded ambiguous.)
+    RETURN VALUE
+    * a Hash containing the option values (default values overwritten
+      with hash).
+    POSSIBLE EXCEPTION
+    * hash has a key that does not match any of the option names.
+    * hash has a key that is ambiguous
+---set(hash)
+    Similar to ((<interpret>)) but changes internal values.
+    ARGUMENTS
+    * hash (Hash) : see ((<interpret>)). (Here, nil is not permitted though)
+    RETURN VALUE
+    * a Hash containing the values replaced (the ones before calling this
+      method)
+    POSSIBLE EXCEPTION
+    * the argument is not a Hash
+    * others are same as in ((<interpret>))
+---help
+    Returns a help message
+    RETURN VALUE
+    * a String describing the option names, default values, and descriptions
+---[](key)
+    Returns a value associated with the key (exact matching unlike interpret)
+---keys
+    Retunrs the keys.
+---select_existent(hash_or_keys)
+    Copies hash_or_keys, exclude ones that are not included in the option
+    (by comparing keys), and returns it. I.e. select only the ones
+    exsitent.
+    NOTE: ambiguity is not checked, so the resultant value is not
+    necessarily accepted by ((<interpret>)).
+    ARGUMENTS
+    * hash_or_keys (Hash or Array)
+    RETURN VALUE
+    * a Hash or Array depending on the class of the argument hash_or_keys
+= class NumRu::Misc::KeywordOptAutoHelp < NumRu::Misc::KeywordOpt
+Same as ((<class NumRu::Misc::KeywordOpt>)), but the method ((<interpret>))
+shows a help message and raise an exception if option 'help' is provided
+as an argument and is not nil or false
+((({NumRu::Misc::HelpMessagingException < StandardError})))
+or if the arguments cannot be interpreted correctly ((({ArgumentError}))).
+Option 'help' is automatically defined, so you do not have to define it
+yourself.
+=end
+module NumRu
+  module Misc
+    class HelpMessagingException < StandardError
+    end
+    class KeywordOpt
+      def initialize(*args)
+	# USAGE:
+	#    KeywordOpt.new([key,val,description],[key,val,description],..)
+	#    where key is a String, and description can be omitted.
+	@val=Hash.new
+	@description=Hash.new
+	@keys = []
+	args.each{ |x|
+	  case x
+	  when Array
+	    unless (x[0]=='help') && @keys.include?(x[0])
+	      #^only 'help' can overwrap in the arguments
+	      @keys.push(x[0])
+	      @val[x[0]] = x[1]
+	      @description[x[0]] = ( (x.length>=3) ? x[2] : '' )
+	    end
+	  when KeywordOpt
+	    x.keys.each{|k|
+	      unless k=='help' && @keys.include?(k)
+	        #^only 'help' can overwrap in the arguments
+		@keys.push(k)
+		@val[k] = x  #.val[k]
+		@description[k] = x.description[k]
+	      end
+	    }
+	    def @val.[](k)
+	      val = super(k)
+	      val.is_a?(KeywordOpt) ? val[k] : val
+	    end
+	    def @val.dup
+	      out = Hash.new
+	      each{|k,val| out[k] = (val.is_a?(KeywordOpt) ? val[k] : val)}
+	      out
+	    end
+	  else
+	    raise ArgumentError, "invalid argument: #{x.inspect}"
+	  end
+	}
+	@keys_sort = @keys.sort
+	if @keys_sort.length != @keys_sort.uniq.length
+	  raise ArgumentError, "keys are not unique"
+	end
+      end
+      def interpret(hash)
+	return @val.dup if hash.nil?
+	##
+	len = @val.length
+	im = 0
+	out = @val.dup
+	hash.keys.sort.each do |key|
+	  rkey = /^#{key}/
+	  loop do
+	    if rkey =~ @keys_sort[im]
+	      if im<len-1 && rkey=~@keys_sort[im+1] &&
+		 key != @keys_sort[im]   # not identical
+		raise ArgumentError, "Ambiguous key specification '#{key}'."
+	      end
+	      out[@keys_sort[im]]=hash[key]
+	      break
+	    end
+	    im += 1
+	    if im==len
+	      raise ArgumentError, "'#{key}' does not match any of the keys."
+	    end
+	  end
+	end
+	out
+      end
+      def select_existent(hash_or_keys)
+	hash_or_keys = hash_or_keys.dup         # not to alter the original
+	len = @val.length
+	im = 0
+	kys = ( Array === hash_or_keys ? hash_or_keys : hash_or_keys.keys )
+	kys.sort.each do |key|
+	  rkey = /^#{key}/
+	  loop do
+	    break if rkey =~ @keys_sort[im]
+	    im += 1
+	    if im==len
+	      hash_or_keys.delete(key)
+	      im = 0           # rewind
+              break
+	    end
+	  end
+	end
+	hash_or_keys
+      end
+      def set(hash)
+	raise ArgumentError, "not a hash" if !hash.is_a?(Hash)
+	##
+	replaced = Hash.new
+	len = @val.length
+	im = 0
+	hash.keys.sort.each do |key|
+	  rkey = /^#{key}/
+	  loop do
+	    if rkey =~ @keys_sort[im]
+	      if im<len-1 && rkey=~@keys_sort[im+1]
+		raise "Ambiguous key specification '#{key}'."
+	      end
+	      replaced[@keys_sort[im]] = @val[@keys_sort[im]]
+	      @val[@keys_sort[im]]=hash[key]
+	      break
+	    end
+	    im += 1
+	    raise "'#{key}' does not match any of the keys." if im==len
+	  end
+	end
+	replaced
+      end
+#      def __line_feed(str)
+#	if str.length >= 68
+#	  idx = str[0..67].rindex(/\s/)
+#	  if idx
+#	    str[idx, 1] = "\n\t"
+#	  end
+#	end
+#	str
+#      end
+      def __line_feed(str, len)
+	if str.length >= len
+	  idx = str[0...len].rindex(/\s/)
+	  if idx
+	    str = str[0...idx] + "\n\t\t\t# " + __line_feed(str[(idx+1)..-1],50)
+	  end
+	end
+	str
+      end
+      private :__line_feed
+      def help
+	 "  option name\tdefault value\t# description:\n" +
+	 @keys.collect{|k|
+	   __line_feed("  #{k.inspect}\t#{@val[k].inspect}\t# #{@description[k]}", 66)
+	 }.join("\n")
+      end
+      def [](k)
+	v = @val[k]
+	if v.is_a?(KeywordOpt)
+	  v = v.val[k]
+	end
+	v
+      end
+      def keys
+	@keys.dup
+      end
+      ##### protected methods #####
+      protected
+      attr_reader :val, :description
+    end
+    ##################################################
+    class KeywordOptAutoHelp < KeywordOpt
+      def initialize(*args)
+	args.push(['help',  false, 'show help message if true'])
+	super(*args)
+      end
+      def interpret(hash)
+	begin
+	  out = super(hash)
+	rescue
+	  raise $!.inspect + "\n  Available parameters are:\n" + help
+	end
+	if out['help']
+	  puts 	"<< Description of options >>\n" + help
+	  puts ' Current values=' + out.inspect
+	  raise Misc::HelpMessagingException, '** help messaging done **'
+	end
+	out
+      end
+      def set(hash)
+	raise ArgumentError, "not a hash" if !hash.is_a?(Hash)
+	if hash['help']
+	  puts 	"<< Description of options >>\n" + help
+	  raise Misc::HelpMessagingException, '** help messaging done **'
+	end
+	super
+      end
+    end
+  end
+end
+if __FILE__ == $0
+  include NumRu
+  class Foo
+    @@opt_hoge = Misc::KeywordOpt.new(
+      ['flag',   false, 'whether or not ...'],
+      ['number', 1,     'number of ...'],
+      ['fff',    1,     'fff...'],
+      ['help',  false, 'show help message']
+    )
+    def self.change_default(hash)
+      @@opt_hoge.set(hash)
+    end
+    def hoge(regular_arg1, regular_arg2, options=nil)
+      opt = @@opt_hoge.interpret(options)
+      if opt['help']
+        puts "* Description of options:\n" + @@opt_hoge.help
+        puts ' Current values='+opt.inspect
+        raise Misc::HelpMessagingException, '** show help message and raise **'
+      end
+      # do what you want below
+      # (options are set in the Hash opt: opt['flag'] and opt['number'])
+      p opt
+    end
+  end
+  foo = Foo.new
+  x = 1
+  y = 1
+  print "### 0 ###\n"
+  foo.hoge( x, y, {'flag'=>true, 'number'=>10} )
+  foo.hoge( x, y )
+  print "### 1 ###\n"
+  foo.hoge( x, y, 'fla'=>true, 'num'=>10 )
+  print "### 2 ###\n"
+  begin
+    foo.hoge( x, y, 'help'=>true )
+  rescue
+    puts $!
+  end
+  print "### 3 ###\n"
+  Foo.change_default( {'number'=>3} )
+  begin
+    foo.hoge( x, y, 'fla'=>true, 'num'=>10, 'help'=>true)
+  rescue
+    puts $!
+  end
+  print "### 4 ###\n"
+  begin
+    foo.hoge( x, y, 'dummy'=>nil)
+  rescue
+    puts $!
+  end
+  print "### 5 ###\n"
+  begin
+    foo.hoge( x, y, 'f'=>nil)
+  rescue
+    puts $!
+  end
+  print "\n######  test of KeywordOptAutoHelp ######\n"
+  opt = Misc::KeywordOptAutoHelp.new(
+    ['flag',   false, 'whether or not ...'],
+    ['number', 1,     'number of ...']
+  )
+  print "### 11 ###\n"
+  begin
+    opt.interpret('flag'=>10,'help'=>true)
+  rescue
+    puts $!
+  end
+  print "### 12 ###\n"
+  begin
+    opt.interpret('nnn'=>10)
+  rescue
+    puts $!
+  end
+  print "### 13 ###\n"
+  opt2 = Misc::KeywordOptAutoHelp.new(
+    ['flafla',   false, 'whether or not ...']
+  )
+  opt3 = Misc::KeywordOptAutoHelp.new( opt, opt2 )
+  p opt3.interpret('flag'=>true)
+  begin
+    opt3.interpret('help'=>true)
+  rescue
+    puts $!
+  end
+  print "### 14 ###\n"
+  p opt2.keys, opt.keys
+  p opt.select_existent({"flag"=>99, "num"=>88, 'acb'=>333})
+  p opt.select_existent(["flag", "num", 'acb'])
+end