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

numru-misc 0.1.1

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