nth 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0c10f19b1c301e8ffc6f258130db8ffbd2f8c130
-  data.tar.gz: 62eaf00edd9b43a9f90fb37fc999e63f716c8265
+SHA256:
+  metadata.gz: 4a4fce17c6efcc75cf89e5b36527176f4b802181a2316604ee335d8b5dfbfe0a
+  data.tar.gz: 3638a58a6b22aea56b8595b2a0ffa06d95af0920bd9a55bb942bf1fd8521bc60
 SHA512:
-  metadata.gz: f0cd825999996083de42303889eda82af352266d63541e31e44b9dd2bd71ef644e6315b65a9f62e4f81e84661c6877e13d3f0303d6661d2d506c50a1d3ca0c91
-  data.tar.gz: 7583d55d091c35c55122db0edc64eaceb1f79ae99fa4fc7bf8bdfe5f3df899731e77689367c778eec13f188bc1c326446b94416524192d8185941cad795d59e7
+  metadata.gz: e922ea67a821019afcffcd1e0f51541bf920255a0b4a2da4bce8055d6904dd401bf5f7df31f5d0865ee231832834dc6fd8115b4bc95ab16dd339c9f8991fbcd1
+  data.tar.gz: c7e5ac4703133a07f5619e58f57dcd0471c92538ca23a2995dc8bbd254f02fae753e11c3f9c7ee42f614dd65de6487019b34b028821ef7d7a4468a481b8c36cf

data/README.md

@@ -1,6 +1,13 @@
 # Nth
 
-For now I am reserving the name. The first real release will be version 0.1.0 some day soon.
+The Nth gem is a collection of utilities that use named numbers and ordinals to represent or access data.
+If you starting singing eight quintillion bottles of beer on the wall at the start of the big bang,
+you would still be signing it today!
+The gem supports numbers bigger than a milliquadragintillion (over 3000 zeros).
+A way smaller number septemvigintillion is more than the number of atoms in the Universe; it only has 84 zeros.
+Asside from ridiculously large numbers, there are also some useful utilities using named numbers.
+As an example we can access the `#twelfth` character of a string.
+Cookbook applications might like to use named measurements such as 'five and three quarters'.
 
 ## Installation
 
@@ -20,8 +27,310 @@ Or install it yourself as:
 
 ## Usage
 
-It would be fun to access the `nth` character of a String or the `nth` element of an Array using ordinals such as `#third` and `#fifth`.
-Another goal is to create an `#to_nth` method on Integer that does this: `5.to_nth == '5th'`. Also, `#to_ordinal` such as `12.to_ordinal == 'twelfth'`.
+The Nth gem has methods that can be used out of the box. Instead you can install these methods to base classes such as `Integer` or `String`.
+This document will first explain how to install various utilities or a subset of available utilities to base classes.
+The last part of the document shows how to use some of the utilities without installing methods to base classes.
+Note that access methods must be installed.
+
+### Access Methods
+
+Instead of using the `[]` and `[]=` operators, on `Arrays` or `Strings` we can access elements using ordinals.
+This can also be applied to custom objects provided certain methods have been implemented.
+There are two mechanisms that can applied in order to endow a class with ordinal access.
+The preferred means utilizes a generator that defines a subset of ordinal access methods.
+The other uses the `method_missing` dynamic system of ghost methods which is less performant.
+As you only get to override `method_missing` once, you should be careful that some other library has not already done this.
+Note that both can be used at the same time; this allows for the more common ordinals to provide faster access.
+These access methods must be installed on a base class before they become active.
+Such installation should only be placed in your startup code.
+This is best seen by example as follows:
+
+```ruby
+require 'Nth'
+"".respond_to? :first  # false ... ordinal access not installed yet
+"".respond_to? :last   # false
+
+Nth::install(:AccessOrdinals, String, 5) 
+# above installs: #first, #second, #third, #fourth, #fifth, and #last  methods
+
+str = "This is a test!"
+str.first   #  'T'
+str.last    #  '!'
+str.fourth  #  's'
+str.fifth   #  ' '
+str.sixth   #  error not defined
+str.fifth = '_'  # str == "This_is a test!"
+
+# add more ordinals ...
+Nth::install(:AccessOrdinals, String, 25, '.')  # '.' is the fill parameter ... ' ' is the default
+
+str.methods.include? :twenty_fifth   # true
+str.methods.include? :twenty_fifth=  # true
+
+str = "testing "
+str.twenty_fifth = " 1,2,3"  # str == "testing ................ 1,2,3"
+
+# add all ordinals using method missing ...
+Nth::install(:AccessAllOrdinals, String, '?')
+
+str.methods.include? :thirtieth  # false  ... not a real method
+str.respond_to? :thirtieth       # true   ... but will respond to call
+
+str.fourtieth = "$"  # str == "testing ................ 1,2,3?????????$"       
+```
+
+From the above we have the first 25 ordinals defined with actual methods, with the remaining ordinals defined using ghost methods.
+Now if you were to access the ordinal `str.tresvigintillionth = "oops!"`, your computer would run out of memory!
+You can change the fill character by calling: `String.instance_variable_set :@default_insert, ' '`.
+Now we can do the same thing with Arrays as follows:
+
+```ruby
+require 'Nth'
+Nth::install(:AccessOrdinals, Array, 15, "nada")  # defaults to nil if no fill specified
+array = [1,2,3]
+array.fifth = 500  # [1, 2, 3, "nada", 500]
+Nth::install(:AccessAllOrdinals, Array, nil)
+array.tenth = "pi"  # [1, 2, 3, "nada", 500, nil, nil, nil, nil, "pi"]
+```
+
+From the above we have 15 actual ordinal methods, with the remainder implemented using ghost methods.
+Note that you only get one ghost method per class so be judicious.
+Custom objects call also install ordinal access provided that they implement the following methods:
+`:[]`, `:[]=`, `size`. Note that Hash objects don't behave well as they are not ordered numerically like Array or String objects are.
+
+### Integer Methods
+
+Integer methods must be installed before they become available.
+Each method creates a string which represents the number in some way.
+Integer methods are installed as follows: `Nth::install(:IntMethods)`.
+Each method is documented in the following subsections.
+
+#### Instance Method `nth`
+
+This method creates a string comprising the number followed by a 2-letter suffix.
+Larger numbers are grouped in 3 and delimited by a comma.
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:IntMethods)
+
+5.nth  # "5th"
+1.nth  # "1st"
+22.nth # "22nd"
+63.nth # "63rd"
+11.nth # "11th"
+0.nth  # "0th"
+-12345673.nth  # "-12,345,673rd"
+```
+
+#### Instance Method `to_number`
+
+This method creates a string name that represents the number.
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:IntMethods)
+
+123456789.to_number # "one hundred twenty-three million four hundred fifty-six thousand seven hundred eighty-nine"
+600013417.to_number # "six hundred million thirteen thousand four hundred seventeen"
+(10**105).to_number # "one quattuortrigintillion" 
+```
+
+#### Instance Method `to_ordinal`
+
+This method creates a string name that represents the ordinal name of the number.
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:IntMethods)
+
+123456783.to_ordinal # "one hundred twenty-three million four hundred fifty-six thousand seven hundred eighty-third"
+600013412.to_ordinal # "six hundred million thirteen thousand four hundred twelfth"
+(10**105).to_ordinal # "one quattuortrigintillionth" 
+```
+
+#### Instance Method `cents_to_dollars`
+
+This method creates a string money name that could be used to print checks.
+The integer represents the number of pennies.
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:IntMethods)
+
+1458312.cents_to_dollars  # "fourteen thousand five hundred eighty-three dollars and twelve cents"
+101.cents_to_dollars      # "one dollar and one cent"
+56.cents_to_dollars       # "zero dollars and fifty-six cents"
+200.cents_to_dollars      # "two dollars and zero cents"
+```
+
+#### Instance Method `pence_to_pounds`
+
+This method creates a string money name that could be used to print checks.
+The integer represents the number of pence. This is the British version of `cents_to_dollars`. 
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:IntMethods)
+
+1458312.pence_to_pounds  # "fourteen thousand five hundred eighty-three pounds and twelve pence"
+101.pence_to_pounds      # "one pound and one penny"
+56.pence_to_pounds       # "zero pounds and fifty-six pence"
+200.pence_to_pounds      # "two pounds and zero pence"
+```
+
+### Float Methods
+
+Float methods must be installed before they become available.
+There are a variety of methods that implement a variety of utilities.
+Float methods are installed as follows: `Nth::install(:FloatMethods)`.
+Each method is documented in the following subsections.
+
+#### Instance Method `to_fractional_unit(unit_name, mode = :descriptive, tar=0.01)`
+
+This method converts a floating point number to a unit based fraction with a multiplicity of formats.
+The `unit_name` parameter use use the singular noun; the method will pluralized the noun when appropriate.
+The `mode` parameter formats the resulting string; this will be explained by example later.
+The `tar` parameter defines the target resolution of the fraction; it is the percent error of the fraction.
+This routine is most useful for cookbook applications. See example below:
+
+```ruby
+require 'Nth'         
+Nth::install(:FloatMethods)  # do this once in the initialization section of your code
+
+cups = 4.333333
+cups.to_fractional_unit('cup')             #  "four and one third cups"
+cups.to_fractional_unit('cup', :numeric)   #  "4 1/3 cups"
+(1.0).to_fractional_unit('cup', :numeric)  #  "1 cup"
+
+#  mode :utf    uses fraction glyphs if available ... uses digits for whole numbers
+#  mode :html   uses fraction glyphs via html ampersand semicolon syntax
+```
+
+#### Instance Method `inches_to_feet(mode = :descriptive, denom=16)`
+
+This method converts floating point inches to a string comprising feet and inches.
+The parameter `mode` defines how the resulting string is formatted.
+The `denom` parameter specifies the target resolution; for proper tape measure formate, this should be a power of `2`.
+See the examples below:
+
+```ruby
+require 'Nth'         
+Nth::install(:FloatMethods)
+
+data = 123.4567
+data.inches_to_feet                     #  "ten feet three and seven sixteenth inches"
+data.inches_to_feet(:numeric_long)      # "10 feet 3 7/16 inches"
+data.inches_to_feet(:numeric_short)     # "10ft 3 7/16in"
+data.inches_to_feet(:numeric_short,32)  # "10ft 3 15/32in"
+(13.0).inches_to_feet                   # "one foot one inch"
+# mode == :tics_utf  uses utf tic marks
+# mode == :tics_html same as above but uses html entities to represent tic marks
+# FYI:: love to show you an example, but can't display UTF chars in *.md document
+```
+
+#### Instance Method `inches_to_yards(mode = :descriptive, denom=16)`
+
+Similar to `inches_to_feet`, but instead separates number into three fields: yards, feet, inches.
+This uses the same parameters as `inches_to_feet`, except `tics_utf` and `tics_html` are not supported.
+
+
+#### Instance Method `to_dms(frac_sec==2)`
+
+This turns geographical floating point numbers into degrees, minutes, and seconds.
+The routine produces utf chars that include degree glyphs as well as tic marks.
+The parameter `frac_sec` defines the number of displayed fractional digits in the seconds field.
+
+### Nth Module direct methods
+
+This section details various methods that can be used without having to perform an installation to a class.
+There are several utility methods that are not documented as they are called by more useful methods.
+There are also methods that are not available in the installed section that have some utility.
+
+#### `Nth::pluralize(str)`
+
+This seemingly unrelated method is used to pluralize unit names; but it can be used on other nouns as well.
+This routine also handles most exceptions. See the example below:
+
+```ruby
+require 'Nth' 
+
+Nth::pluralize('foot')     # 'feet'
+Nth::pluralize('octopus')  # "octopi"
+Nth::pluralize('box')      # "boxes"
+Nth::pluralize('wife')     # "wives"
+Nth::pluralize('kiss')     # "kisses"
+Nth::pluralize('fish')     # "fish"
+Nth::pluralize('die')      # "dice"
+```
+
+#### `Nth::get_number_name(int, *flags)`
+
+This converts an integer to a named number. The `flags` parameter list defines the final string formatting.
+This is best seen by example as follows:
+
+```ruby
+require 'Nth' 
+# flags are as follows:
+# :-_                 separate each word with an underscore
+# :-                  use dashes on some word combinations such as: twenty-six
+# :plus_minus         prefix number with 'plus' or 'minus'  (default 'minus' if negative else '')
+# :positive_negative  prefix number with 'positive' or 'negative' 
+
+Nth::get_number_name(-13453)     # "minus thirteen thousand four hundred fifty three"
+Nth::get_number_name(13453, :-)  # "thirteen thousand four hundred fifty-three"
+Nth::get_number_name(13453, :_)  # "thirteen_thousand_four_hundred_fifty_three"
+Nth::get_number_name(17, :plus_minus)  # "plus seventeen"
+Nth::get_number_name(17, :positive_negative)  # "positive seventeen"
+Nth::get_number_name(-17, :_, :positive_negative)  # "negative_seventeen"
+```
+
+#### `Nth::get_ordinal_name(int, *flags)`
+
+This routine uses the same flags as `get_number_name`, but instead produces ordinal names. 
+See the example below:
+
+```ruby
+Nth::get_ordinal_name(-13453)  # "minus thirteen thousand four hundred fifty third"
+Nth::get_ordinal_name(-17, :_, :positive_negative)  "negative_seventeenth"
+```
+
+#### Integer Methods without installation
+
+We can access without installation integer methods as follows:
+
+```ruby
+  Nth::IntMethods::to_nth_string(12345)        # "12,345th"
+  Nth::IntMethods::to_nth_string(12345,false)  # "12345th"
+  Nth::IntMethods::penny_to_dollar(12345)  # "one hundred twenty-three dollars and forty-five cents"
+  Nth::IntMethods::pence_to_pound(12345)   # "one hundred twenty-three pounds and forty-five pence"
+```
+
+#### Float Methods without installation
+
+We can access without installation float methods as follows:
+
+```ruby
+  Nth::FloatMethods::to_fractional_unit(3.666666, 'cup', :descriptive, 0.01)  #  "three and two third cups"
+  Nth::FloatMethods::to_fractional_unit(3.666666, 'cup', :numeric, 0.01)      #  "3 2/3 cups"
+  # also modes:  :utf  and  :html 
+  
+  Nth::FloatMethods::inches_to_feet(14.63953, :descriptive, 64)    #  "one foot two and forty-one sixty-fourth inches"
+  Nth::FloatMethods::inches_to_feet(14.63953, :numeric_long, 64)   #  "1 foot 2 41/64 inches"
+  Nth::FloatMethods::inches_to_feet(14.63953, :numeric_short, 64)  #  "1ft 2 41/64in"
+  # also modes:  :tics_utf  and  :tics_html
+  
+  Nth::FloatMethods::inches_to_yards(136.67134, :descriptive, 16)   #  "three yards two feet four and eleven sixteenth inches"
+  Nth::FloatMethods::inches_to_yards(136.67134, :numeric_long, 16)  #  "3 yards 2 feet 4 11/16 inches"
+  Nth::FloatMethods::inches_to_yards(136.67134, :numeric_short, 16) #  "3yd 2ft 4 11/16in"
+  
+  Nth::FloatMethods::to_dms(-121.9361831121, 4)  # can't display on *md file, but try yourself!
+```
 
 ## Development
 

data/lib/nth.rb

@@ -1,25 +1,1162 @@
 require "nth/version"
+require "primitive_wrapper"
 
 module Nth
-  BASE_ORDINALS = 
-['zeroth','first','second','third','fourth','fifth','sixth','seventh','eighth','ninth','tenth',
-'eleventh','twelfth','thirteenth','fourteenth','fifteenth','sixteenth','seventeenth','eighteenth','nineteenth']
-  DEC_ORDINALS = 
-['tenth','twentieth', 'thirtieth', 'fourtieth', 'fiftieth', 'sixtieth', 'seventieth', 'eightieth', 'ninetieth', 'hundredth']
-  EXP_ORDINALS = {100 => 'hundredth', 1000 => 'thousandth', 1000000 => 'millionth', 1000000000 => 'billionth', 1000000000000 => 'trillionth',
-1000000000000000 => 'quadrillionth', 1000000000000000000=> 'quintillionth', 1000000000000000000000 => 'sextillionth',
-1000000000000000000000000 => 'septillionth', 1000000000000000000000000000 => 'octillionth', 1000000000000000000000000000000 => 'nonillionth',
-1000000000000000000000000000000000 => 'decillionth'}
-  NUMBERS = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
-  DEC_NUMBERS = ['ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']
-  module Access
-    def method_missing(*plist, &block)
+
+  FRACTION_UTF  = { "1/2" => '½', "1/4" => '¼', "3/4" => '¾', "1/3" => '⅓', "2/3" => '⅔',
+   "1/8" => '⅛', "3/8" => '⅜',"5/8" => '⅝', "7/8" => '⅞',
+   "1/5" => '⅕',"2/5" => '⅖', "3/5" => '⅗',"4/5" => '⅘',"1/6" => '⅙', "5/6" => '⅚',"1/9" => '⅑',"1/10" => '⅒'}
+  html = {}   
+
+  NUMBERS = {0 => 'zero', 1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four', 5 => 'five', 6 => 'six', 7 => 'seven', 8 => 'eight', 9 => 'nine', 10 => 'ten',
+11 => 'eleven', 12 => 'twelve', 13 => 'thirteen', 14 => 'fourteen', 15 => 'fifteen', 16 => 'sixteen', 17 => 'seventeen', 18 => 'eighteen', 19 => 'nineteen',  
+20 => 'twenty', 30 => 'thirty', 40 => 'forty', 50 => 'fifty', 60 => 'sixty', 70 => 'seventy', 80 => 'eighty', 90 => 'ninety',   
+100 => 'hundred', 
+'10**3'  => 'thousand',
+'10**6'  => 'million', 
+'10**9'  => 'billion', 
+'10**12' => 'trillion',
+'10**15' => 'quadrillion', 
+'10**18' => 'quintillion', 
+'10**21' => 'sextillion',
+'10**24' => 'septillion', 
+'10**27' => 'octillion', 
+'10**30' => 'nonillion',
+'10**33' => 'decillion',
+'10**36' => 'undecillion',
+'10**39' => 'duodecillion',
+'10**42' => 'tredecillion',
+'10**45' => 'quattuordecillion',
+'10**48' => 'quindecillion',
+'10**51' => 'sexdecillion',
+'10**54' => 'septendecillion',
+'10**57' => 'octodecillion',
+'10**60' => 'novemdecillion',   # rule generator makes this   novendecillion
+'10**63' => 'vigintillion',
+'10**66' => 'unvigintillion',
+'10**69' => 'duovigintillion',
+'10**72' => 'tresvigintillion',
+'10**75' => 'quattuorvigintillion',
+'10**78' => 'quinquavigintillion',
+'10**81' => 'sesvigintillion',
+'10**84' => 'septemvigintillion',
+'10**87' => 'octovigintillion',
+'10**90' => 'novemvigintillion',
+'10**93' => 'trigintillion',
+'10**96' => 'untrigintillion',
+'10**99' => 'duotrigintillion',
+'10**102' => 'trestrigintillion',       
+'10**105' => 'quattuortrigintillion',   
+'10**108' => 'quinquatrigintillion',
+'10**111' => 'sestrigintillion',
+'10**114' => 'septentrigintillion',
+'10**117' => 'octotrigintillion',
+'10**120' => 'noventrigintillion',
+'10**123' => 'quadragintillion',
+'10**100' => 'googol',
+'10**3003' => 'millinillion',
+'10**3006' => 'millimillion',
+'10**3009' => 'millibillion',
+'10**3012' => 'millitrillion',
+'10**3015' => 'milliquadrillion',
+'10**3018' => 'milliquintillion',
+'10**3021' => 'millisextillion',
+'10**3024' => 'milliseptillion',
+'10**3027' => 'millioctillion',
+'10**3030' => 'millinonillion',
+'10**3033' => 'millidecillion',
+'10**3036' => 'milliundecillion',
+'10**3039' => 'milliduodecillion',
+'10**3042' => 'millitredecillion',
+'10**3045' => 'milliquattuordecillion',
+'10**3048' => 'milliquindecillion',
+'10**3051' => 'millisexdecillion',
+'10**3054' => 'milliseptendecillion',
+'10**3057' => 'millioctodecillion',
+'10**3060' => 'millinovemdecillion',
+'10**3063' => 'millivigintillion',
+'10**3066' => 'milliunvigintillion',
+'10**3069' => 'milliduovigintillion',
+'10**3072' => 'millitresvigintillion',
+'10**3075' => 'milliquattuorvigintillion',
+'10**3078' => 'milliquinquavigintillion',
+'10**3081' => 'millisesvigintillion',
+'10**3084' => 'milliseptemvigintillion',
+'10**3087' => 'millioctovigintillion',
+'10**3090' => 'millinovemvigintillion',
+'10**3093' => 'millitrigintillion',
+'10**3096' => 'milliuntrigintillion',
+'10**3099' => 'milliduotrigintillion',
+'10**3102' => 'millitrestrigintillion',
+'10**3105' => 'milliquattuortrigintillion',
+'10**3108' => 'milliquinquatrigintillion',
+'10**3111' => 'millisestrigintillion',
+'10**3114' => 'milliseptentrigintillion',
+'10**3117' => 'millioctotrigintillion',
+'10**3120' => 'millinoventrigintillion',
+'10**3123' => 'milliquadragintillion'
+}   
+
+# might go to just under Duomillinillion, but not until next revision
+# to go higher, need the definitive naming scheme.
+
+  ORDINALS = {0 => 'zeroth', 1 => 'first', 2 => 'second', 3 => 'third', 4 => 'fourth', 5 => 'fifth', 6 => 'sixth', 7 => 'seventh', 8 => 'eighth', 9 => 'ninth', 10 => 'tenth',
+11 => 'eleventh', 12 => 'twelfth', 13 => 'thirteenth', 14 => 'fourteenth', 15 => 'fifteenth', 16 => 'sixteenth', 17 => 'seventeenth', 18 => 'eighteenth', 19 => 'nineteenth',  
+20 => 'twentieth', 30 => 'thirtieth', 40 => 'fortieth', 50 => 'fiftieth', 60 => 'sixtieth', 70 => 'seventieth', 80 => 'eightieth', 90 => 'ninetieth',
+100 => 'hundredth', -1 => 'last'
+}
+
+  #NUMBERS.each_pair { |key,val| ords[key] = val + "th" if ords[key].nil? }
+  #ORDINALS = ords.freeze
+  
+
+  ORD_FORMAT_ERROR = "ordinal format error"
+  SET_TRE  = [90,900,70,700,60,600,10,200]  # no need for extra 's'
+  SET_NOVE = [90,900] # no need for extra '?'
+  
+  # see:: https://en.wikipedia.org/wiki/Names_of_large_numbers
+  PRE_TABLE = {}
+  PRE_TABLE["un"]        = {:val=>1, :solo=>false, :sfx => [], :if => [], :rpl => [] }
+  PRE_TABLE["duo"]       = {:val=>2, :solo=>false, :sfx => [], :if => [],  :rpl => [] }
+  PRE_TABLE["tre"]       = {:val=>3, :solo=>false, :sfx => [:s], :if => [:s,:x], :rpl => [] }
+  PRE_TABLE["quattuor"]  = {:val=>4, :solo=>false, :sfx => [], :if => [],  :rpl => [] }
+  PRE_TABLE["quinqua"]   = {:val=>5, :solo=>false, :sfx => [], :if => [],  :rpl => [] }
+  PRE_TABLE["se"]        = {:val=>6, :solo=>false, :sfx => [:s,:x], :if => [:s,:x], :rpl => [] }
+  PRE_TABLE["septe"]     = {:val=>7, :solo=>false, :sfx => [:m,:n], :if => [:m,:n],:rpl => [] }
+  PRE_TABLE["octo"]      = {:val=>8, :solo=>false, :sfx => [], :if => [],:rpl => [] }
+  PRE_TABLE["nove"]      = {:val=>9, :solo=>false, :sfx => [:m,:n], :if => [:m,:n], :rpl => [] }
+
+  PRE_TABLE["dec"]         = {:val=>10, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["vigint"]      = {:val=>20, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:m, :s] }
+  PRE_TABLE["trigint"]     = {:val=>30, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:n, :s] }
+  PRE_TABLE["quadragint"]  = {:val=>40, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:n, :s] }  # quadragintillion  ... the 'a' gets dropped here
+  PRE_TABLE["quinquagint"] = {:val=>50, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:n, :s] }  # maybe best if we drop it here, then add, an `:extra` key 
+  PRE_TABLE["sexagint"]    = {:val=>60, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["septuagint"]  = {:val=>70, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["octogint"]    = {:val=>80, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i,:m, :x] }
+  PRE_TABLE["nonagint"]    = {:val=>90, :solo=>true, :sfx => [:a], :if => [], :rpl => [:a,:i]       }
+  
+  PRE_TABLE["cent"]        = {:val=>100, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n, :x] }
+  PRE_TABLE["ducent"]      = {:val=>200, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["trecent"]     = {:val=>300, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n, :s] }
+  PRE_TABLE["quadringent"] = {:val=>400, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n, :s] }
+  PRE_TABLE["quingent"]    = {:val=>500, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n, :s] }
+  PRE_TABLE["sescent"]     = {:val=>600, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["septingent"]  = {:val=>700, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:n]     }
+  PRE_TABLE["octingent"]   = {:val=>800, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i,:m, :x] }
+  PRE_TABLE["nongent"]     = {:val=>900, :solo=>true, :sfx => [:i], :if => [], :rpl => [:a,:i]       }
+
+  # no example on how to combine with others ... but here it is:  
+  # PRE_TABLE["millin"]     = {:val=>1000, :solo=>false, :sfx => [:i], :if => [], :rpl => [:a,:i]       } 
+  
+  # if you can find a reference for larger, then place here ... best so far ...
+  #  http://answers.wikia.com/wiki/What_number_comes_after_millinillion
+  #  problem with the above is inconsistency with former system.
+  
+  pes = {}
+  pes['sheep']='sheep'
+  pes['series']='series'
+  pes['species']='species'
+  pes['deer']='deer'
+  pes['fish']='fish'
+  pes['child']='children'
+  pes['goose']='geese'
+  pes['man']='men'
+  pes['woman']='women'
+  pes['tooth']='teeth'
+  pes['foot']='feet'
+  pes['mouse']='mice'
+  pes['person']='people'
+  pes['ox']='oxen'
+  pes['photo']='photos'
+  pes['piano']='pianos'
+  pes['halo']='halos'
+  pes['roof']='roofs'
+  pes['belief']='beliefs'
+  pes['chef']='chefs'
+  pes['chief']='chiefs'
+  pes['fez']='fezzes'
+  pes['gas']='gasses'
+  pes['pion']='pions'
+  pes['criterion']='criteria'
+  pes['phenomenon']='phenomena'
+  pes['canto']='cantos'
+  pes['zero']='zeros'
+  pes['cello']='cellos'
+  pes['louse']='lice'
+  pes['die']='dice'
+  pes['child']='children'
+  pes['penny']='pence'
+  pes['person']='people'
+  pes['moose']='moose'
+  pes['swine']='swine'
+  pes['buffalo']='buffalo'
+  pes['shrimp']='shrimp'
+  pes['trout']='trout'
+  pes['aircraft']='aircraft'
+  pes['watercraft']='watercraft'
+  pes['hovercraft']='hovercraft'
+  pes['spacecraft']='spacecraft'
+  
+  PLURAL_EXCPETIONS = pes.freeze
+
+  # utility methods:       the gem pluralize too simple ... maybe you should fix this ...
+  # ::TODO:: move to new gem, then update this gem
+  def self.pluralize(str)
+    str = str.rstrip
+    tst = PLURAL_EXCPETIONS[str]
+    return tst unless tst.nil?
+    ch  = str[-1]
+    sfx = str[-2..-1]  
+    if ['ay','ey','oy','uy','iy'].include? sfx
+      return str + 's'
+    elsif ['is'].include? sfx  # analysis analyses
+      return str[0..-3] +'es'   
+    elsif ['us'].include? sfx  # focus foci
+      return str[0..-3] +'i'
+    elsif sfx=='fe'
+      return str[0..-3] + 'ves'
+    elsif ch=='f'
+      return str[0..-2] + 'ves'
+    elsif ch=='y'
+      return str[0..-2] +'ies'
+    elsif ['s','x','z','o'].include? ch
+      return str +'es'
+    elsif ['ch', 'sh'].include? sfx
+      return str +'es'    
+    elsif ['um'].include? sfx  # datum data
+      return str[0..-3] +'a'   
+    #elsif ['on'].include? sfx  # criterion criteria  <<< more the exception than the rule
+    #  return str[0..-2] +'a' unless str[-3]=='o'  # moon, spoon     ...  pion  peon  son won ton
+    end    
+    return str + 's'
+  end
+  
+  def self.lookup_prefix(str)
+    if (PRE_TABLE.include? str[0..11])    
+      return [str[0..11], PRE_TABLE[str[0..11]]]
+    end
+    if (PRE_TABLE.include? str[0..10])    
+      return [str[0..10], PRE_TABLE[str[0..10]]]
+    end
+    if (PRE_TABLE.include? str[0..9])    
+      return [str[0..9], PRE_TABLE[str[0..9]]]
+    end
+    if (PRE_TABLE.include? str[0..8])    
+      return [str[0..8], PRE_TABLE[str[0..8]]]
+    end
+    if (PRE_TABLE.include? str[0..7])    
+      return [str[0..7], PRE_TABLE[str[0..7]]]
+    end
+    if (PRE_TABLE.include? str[0..6])
+      return [str[0..6], PRE_TABLE[str[0..6]]]
+    end
+    if (PRE_TABLE.include? str[0..5])
+      return [str[0..5], PRE_TABLE[str[0..5]]]
+    end
+    if (PRE_TABLE.include? str[0..4])
+      return [str[0..4], PRE_TABLE[str[0..4]]]
+    end
+    if (PRE_TABLE.include? str[0..3])
+      return [str[0..3], PRE_TABLE[str[0..3]]]
+    end  
+    if (PRE_TABLE.include? str[0..2])
+      return [str[0..2], PRE_TABLE[str[0..2]]]
     end
+    if (PRE_TABLE.include? str[0..1])
+      return [str[0..1], PRE_TABLE[str[0..1]]]
+    end
+    return [nil,nil]
   end
+  
+  def self.calculate_prefix(str)   # see: https://en.wikipedia.org/wiki/Names_of_large_numbers
+    raise ORD_FORMAT_ERROR unless str.index('ii').nil?
+    str = str.dup
+    m = 0
+    if (str[0..4]=='milli')
+      m = 1000
+      str = str[5..-1]
+    end
+    n = 0
+    pre, props = lookup_prefix(str)
+    raise ORD_FORMAT_ERROR if pre.nil?
+    if props[:val] < 10
+      n += props[:val]
+      if props[:if].empty? # simple case
+        str = str[pre.length..-1]
+        pre, props = lookup_prefix(str)
+      else  # tricky case
+        str = str[pre.length..-1]
+        pre, sfx = lookup_prefix(str)
+        if pre.nil?
+          xs = str[0]
+          str = str[1..-1]
+          pre, sfx = lookup_prefix(str)
+          raise ORD_FORMAT_ERROR if pre.nil?
+          ch = (props[:if] & sfx[:rpl]).first.to_s
+          unless ch==xs
+            ch = ch.to_sym
+            raise ORD_FORMAT_ERROR unless props[:if].include? ch
+            raise ORD_FORMAT_ERROR unless props[:sfx].include? xs.to_sym
+          end
+        else
+          raise ORD_FORMAT_ERROR unless (props[:if] & sfx[:rpl]).empty?
+        end
+        props = sfx       
+      end
+    end
+    if pre && (props[:val] < 100)
+      str = str[pre.length..-1]
+      n += props[:val]
+      pre, sfx = lookup_prefix(str)
+      if pre.nil?
+        ch = str[0]
+        str = str[1..-1]
+        pre, sfx = lookup_prefix(str)
+        unless pre.nil?
+          cch = (sfx[:rpl] & props[:sfx]).first.to_s
+          raise ORD_FORMAT_ERROR unless cch == ch
+        end
+        props = sfx
+      end
+    end
+    if pre && (props[:val] < 1000)
+      str = str[pre.length..-1]
+      n += props[:val]
+      pre, sfx = lookup_prefix(str)
+      raise ORD_FORMAT_ERROR unless pre.nil?  # too many!
+    end
+    n += m    
+    raise ORD_FORMAT_ERROR if n <= 10
+    n *= 3
+    n = 10 ** (n+3)
+    return n
+  end
+  
+  # this only looks up a single item... need to expand for other prefixes/
+  def self.lookup_number(num)
+    return eval(NUMBERS.key(num).to_s) if (NUMBERS.values.include? num)
+    if ("illion" == num[-6..-1])
+      # str = num[0..-7]
+      return calculate_prefix(num)
+    end
+    return nil
+  end
+
+  def self.lookup_ordinal(ordinal)
+    return 0 if (ordinal=="last")
+    return eval(ORDINALS.key(ordinal).to_s) if (ORDINALS.values.include? ordinal)
+    str = ordinal[0..-3]
+    return lookup_number(str)
+  end
+  
+  def self.num_ord_string_to_ary(str)
+    return str.split('_') if str.index(' ').nil?  # underscore format
+    ary = []
+    aaa = str.split ' '
+    aaa.each do |elm|
+      ary += elm.split '-'
+    end
+    return ary
+  end
+  
+  def self.number_string_to_number(str_ary)
+    sum = 0
+    psum = 0
+    neg = false
+    if str_ary.kind_of? String
+      ary = num_ord_string_to_ary(str_ary)
+    else
+      ary = str_ary
+    end    
+    ary.each do |elm|
+      if elm == 'minus'
+        neg = true
+        break
+      end 
+      num = lookup_number(elm)
+      return nil if num.nil?
+      if num < 1000
+        if psum==0
+          psum = num
+        elsif num > psum
+          psum *= num  
+        else
+          psum += num
+        end
+      else
+        sum += num * psum
+        psum = 0
+      end
+    end
+    sum += psum
+    sum = -sum if neg
+    return sum
+  end
+
+  def self.ordinal_string_to_number(str)
+    return -1 if str=="last"
+    sum = 0
+    ary = num_ord_string_to_ary(str)
+    nth = ary.pop
+    val = lookup_ordinal(nth)
+    return nil if val.nil?
+    ary.push get_number_name(val).split(' ').last
+    num = number_string_to_number(ary)
+    return nil if num.nil?
+    return num-1
+  end
+  
+  ### these may need to be redone ...
+  def self.get_n_from_array(ary)
+    if("minus"==ary.first)
+      n = get_n_from_array(ary[1..-1])
+      return nil if n.nil?
+      return -n
+    end
+    a = lookup_number(ary[0])
+    if a.nil?
+      a = lookup_ordinal(a[0])
+      return nil if a.nil?
+      raise ORD_FORMAT_ERROR if is ary.size > 1
+      return a
+    end
+    b = lookup_number(ary[1])
+    if b.nil?
+      b = lookup_ordinal(ary[1])
+      raise ORD_FORMAT_ERROR if b.nil?
+      raise ORD_FORMAT_ERROR unless ary[2].nil?
+      if a > b  # forty_fourth
+      else
+      end
+    else
+    end
+    nil
+  end
+
+  def self.get_n_from_string(ordinal)
+    n = lookup_ordinal(ordinal)
+    return n unless n.nil? 
+    return get_n_from_array(ordinal.split('_'))
+  end
+  
+  
+  def self.get_number_struct(int)
+    neg = int < 0
+    int = -int if neg
+    dat = []
+    while(int > 0)
+      int, triplet = int.divmod 1000
+      dat.push triplet
+    end
+    dat.push neg ? :neg : :pos
+  end
+  
+  def self.create_big_number_name(mult)
+    pre = ""
+    num = (mult-3) / 3
+    if (num >= 1000)
+      idx = "10**#{mult}"
+      rtn = NUMBERS[idx]
+      return rtn unless rtn.nil?
+      pre = "milli"
+      num -= 1000
+      raise "Number too big" if num >= 1000  # next revision may address larger numbers
+    end
+    huns, dec  = num.divmod 100
+    tens, ones = dec.divmod 10
+    str = ""
+    unless ones.zero?
+      if    (1==ones)
+        str = "un"
+      elsif (2==ones)
+        str = "duo"
+      elsif (3==ones)
+        str = "tre"
+        if [2,3,4,5,8].include? tens
+          str += 's'
+        elsif tens.zero?
+          if [1,3,4,5,8].include? huns
+            str += 's'
+          end
+        end
+      elsif (4==ones)
+        str = "quattuor"
+      elsif (5==ones)
+        str = "quinqua"
+      elsif (6==ones)
+        str = "se"
+        if [2,3,4,5].include? tens
+          str += 's'
+        elsif 8==tens
+          str += 'x'  
+        elsif tens.zero?
+          if [3,4,5].include? huns
+            str += 's'
+          elsif [1,8].include? huns  
+            str += 'x'
+          end
+        end
+      elsif (7==ones)
+        str = "septe"
+        if [1,8].include? tens
+          str += 'm'
+        elsif [1,3,4,5,6,7].include? tens
+          str += 'n'
+        elsif tens.zero?
+          if (1..7).include? huns
+            str += 'n'
+          elsif 8 == huns
+            str += 'm'
+          end
+        end
+      elsif (8==ones)
+        str = "octo"
+      elsif (9==ones)
+        str = "nove"
+        if [1,8].include? tens
+          str += 'm'
+        elsif [1,3,4,5,6,7].include? tens
+          str += 'n'
+        elsif tens.zero?
+          if (1..7).include? huns
+            str += 'n'
+          elsif 8 == huns
+            str += 'm'
+          end
+        end
+      end  
+    end
+    unless tens.zero?
+      if    (1==tens)
+        str += 'dec' 
+        str += 'i' unless huns.zero?  
+      elsif (2==tens)    
+        str += 'vigint'   
+        str += 'i' unless huns.zero?  
+      elsif (3==tens)    
+        str += 'trigint'   
+        str += 'a' unless huns.zero?  
+      elsif (4==tens)    
+        str += 'quadragint'   
+        str += 'a' unless huns.zero?  
+      elsif (5==tens)    
+        str += 'quinquagint'   
+        str += 'a' unless huns.zero?  
+      elsif (6==tens)    
+        str += 'sexagint'   
+        str += 'a' unless huns.zero?  
+      elsif (7==tens)    
+        str += 'septuagint'   
+        str += 'a' unless huns.zero?  
+      elsif (8==tens)    
+        str += 'octogint'   
+        str += 'a' unless huns.zero?  
+      elsif (9==tens)    
+        str += 'nonagint'   
+        str += 'a' unless huns.zero?  
+      end
+    end
+    unless huns.zero?
+      if    (1==huns)
+        str += 'cent'   
+      elsif (2==huns)    
+        str += 'ducent'   
+      elsif (3==huns)    
+        str += 'trecent'   
+      elsif (4==huns)    
+        str += 'quadringent'   
+      elsif (5==huns)    
+        str += 'quingent'   
+      elsif (6==huns)    
+        str += 'sescent'   
+      elsif (7==huns)    
+        str += 'septingent'   
+      elsif (8==huns)    
+        str += 'octingent'   
+      elsif (9==huns)    
+        str += 'nongent'   
+      end
+    end
+    return pre + str + 'illion'
+  end
+  
+  def self.get_number_name(int, *flags)    
+    ary = get_number_struct(int)
+    neg = ary.pop == :neg
+    return NUMBERS[0] if ary.empty?
+    ary.reverse!
+    mult = 0
+    str = ""
+    ch  = flags.include?(:_) ? "_" : " "
+    tch = flags.include?(:-) ? "-" : ch
+    loop do
+      break if ary.empty?
+      num = ary.pop
+      hun, dec = num.divmod 100
+      tstr = ""
+      unless hun.zero?
+        tstr = NUMBERS[hun] + ch + NUMBERS[100]
+        unless dec.zero?
+          tstr += ch
+        end
+      end
+      unless dec.zero?
+        if NUMBERS[dec].nil?
+          tens, ones = dec.divmod 10
+          tstr += NUMBERS[tens*10] + tch + NUMBERS[ones]
+        else
+          tstr += NUMBERS[dec]
+        end
+      end
+      unless tstr.empty?
+        if mult.zero?
+          str = tstr
+        else
+          ms = "10**#{mult}"
+          mm = NUMBERS[ms]  # if you run out, you will need a generator 
+          mm = create_big_number_name(mult) if mm.nil?
+          if str.empty?
+            str = tstr + ch + mm
+          else
+            str = tstr + ch + mm + ch + str
+          end
+        end        
+      end
+      mult += 3
+    end
+    if flags.include? :plus_minus
+      if neg # use default
+        return "minus" + ch + str
+      end
+      return "plus" + ch + str
+    end
+    if flags.include? :positive_negative
+      if neg # use default
+        return "negative" + ch + str
+      end
+      return "positive" + ch + str
+    end
+    if neg # use default
+      return "minus" + ch + str
+    end
+    return str    
+  end
+
+  def self.get_ordinal_name(int, *flags)
+    return ORDINALS[0] if int.zero?
+    ch  = flags.include?(:_) ? "_" : " "
+    tch = flags.include?(:-) ? "-" : ch
+    if int.negative?
+      if flags.include? :positive_negative
+        pre = "negative" + ch
+      else flags.include? :plus_minus
+        pre = "minus" + ch
+      end
+    else
+      if flags.include? :positive_negative
+        pre = "positive" + ch
+      elsif flags.include? :plus_minus
+        pre = "plus" + ch
+      else 
+        pre = ""  
+      end
+    end
+    flags = flags - [:positive_negative, :plus_minus]
+    int = int.abs
+    n1,n2 = int.divmod 100
+    unless n2.zero?
+      n1 *= 100
+      if n1.zero?
+        str = pre
+      else
+        str = pre + get_number_name(n1, *flags)
+        str += ch
+      end
+      if ORDINALS.include? n2
+        str += ORDINALS[n2]
+        return str
+      end
+      n1,n2 = n2.divmod 10
+      n1 *= 10
+      str += NUMBERS[n1] + tch + ORDINALS[n2]
+      return str
+    end
+    return pre + get_number_name(int, *flags) + "th"
+  end
+    
+  def self.get_denominator_name(int)
+    return "half"    if 2==int
+    return "quarter" if 4==int
+    return get_ordinal_name(int, :-)
+  end
+  
+  # methods to include in base classes:
+  module AccessMethods
+    def self.get_ordinal_at(object, ordinal)
+      n = Nth::get_n_from_string(ordinal)
+      return nil if n.nil?
+      return object[n-1]
+    end
+  end
+  
   module IntMethods
-    def to_nth
+    def self.to_nth_string(int, comma=true)
+      # 0th, 1st, 2nd, 3rd, 4th, 5th, 6th, 7th, 8th, 9th
+      pre = int.negative? ? "-" : ""
+      int = int.abs
+      teen = int % 100
+      if comma
+        str = int.to_s.reverse.scan(/\d{1,3}/).join(',').reverse
+      else
+        str = int.to_s
+      end
+      if (teen >= 4) && (teen <= 19)
+        return pre + str + "th"
+      end
+      ones = int % 10
+      return (pre + str + "st") if ones == 1
+      return (pre + str + "nd") if ones == 2
+      return (pre + str + "rd") if ones == 3
+      return pre + str + "th"
+    end
+    def self.to_ordinal_string(int)
+      Nth::get_ordinal_name(int, :-)
+    end
+    def self.to_number_string(int)
+      Nth::get_number_name(int, :-)
     end
-    def to_ordinal
+    def self.penny_to_dollar(int)
+      neg = int.negative? ? "minas " : ""
+      int = int.abs
+      dollars, cents = int.divmod 100
+      ds = dollars == 1 ? "" : "s"
+      cs = cents == 1 ? " cent" : " cents"
+      return neg + to_number_string(dollars) + " dollar#{ds} and " + to_number_string(cents) + cs
+    end
+    def self.pence_to_pound(int)
+      neg = int.negative? ? "minas " : ""
+      int = int.abs
+      pounds, pence = int.divmod 100
+      ps = pounds == 1 ? "" : "s"
+      pp = pence == 1 ? " penny" : " pence"
+      return neg + to_number_string(pounds) + " pound#{ps} and " + to_number_string(pence) + pp
+    end
+  end
+  
+  module FloatMethods
+    # :numeric      ...  3 1/4 cups
+    # :descriptive  ... three and one quarter cups
+    # :utf          ... 3¼ cups
+    # :html         ... 3&amp;#188; cups    
+    def self.to_fractional_unit(flt, unit_name, mode = :descriptive, tar=0.01)  # inch, cup, teaspoon etc
+      if :numeric==mode
+        frac=Fraction(flt,tar).to_s(false).to_s  # work_around for now  ... bump revision on prim_wrap gem
+        ary = frac.split(' ')
+        if 1==ary.count
+          str = ary.first
+          if str.include? '/'
+            return "#{str} #{unit_name}"
+          else
+            if '1'==str
+              return "1 #{unit_name}"
+            else
+              return "#{str} #{Nth::pluralize(unit_name)}"
+            end
+          end
+        else
+          return "#{ary.first} #{ary.last} #{Nth::pluralize(unit_name)}"
+        end
+      elsif :descriptive==mode
+        ##  get_denominator_name(int)   get_number_name(int, *flags) 
+        ##Nth::pluralize(str)
+        frac=Fraction(flt,tar).to_s(false).to_s
+        ary = frac.split(' ')
+        
+        if 1==ary.count
+          str = ary.first
+          if str.include? '/'
+            ary = str.split('/')
+            top = ary.first.to_i
+            bot = ary.last.to_i
+            top = Nth::get_number_name(top, :-)
+            denom = Nth::get_denominator_name(bot)
+            return "#{top} #{denom} #{unit_name}"
+          else
+            if '1'==str
+              return "one #{unit_name}"
+            else
+              num = ary.first.to_i
+              name = Nth::get_number_name(num, :-)
+              return "#{name} #{Nth::pluralize(unit_name)}"
+            end
+          end
+        else
+          str   = Nth::get_number_name(ary.first.to_i, :-) + " and "
+          ary   = ary.last.split('/')
+          top   = ary.first.to_i
+          bot   = ary.last.to_i
+          denom = Nth::get_denominator_name(bot)
+          # denom = Nth::pluralize(denom) unless top==1
+          top   = Nth::get_number_name(top, :-)
+          return str + "#{top} #{denom} #{Nth::pluralize(unit_name)}"
+        end
+      elsif [:utf,:html].include? mode
+        frac=Fraction(flt,tar).to_s(false).to_s  # work_around for now  ... bump revision on prim_wrap gem
+        ary = frac.split(' ')
+        if 1==ary.count
+          str = ary.first
+          if str.include? '/'
+            utf = FRACTION_UTF[str]
+            return "#{str} #{unit_name}" if utf.nil?
+            if :utf==mode
+              return "#{utf} #{unit_name}"
+            else
+              return '&#' + "#{utf.ord}; #{unit_name}"
+            end
+          else
+            if '1'==str
+              return "1 #{unit_name}"
+            else
+              return "#{str} #{Nth::pluralize(unit_name)}"
+            end
+          end
+        else
+          utf = FRACTION_UTF[ary.last]
+          if utf.nil?
+            utf = ' ' + ary.last
+          elsif :html==mode
+            utf = '&#' + "#{utf.ord};"
+          end
+          return "#{ary.first}#{utf} #{Nth::pluralize(unit_name)}"
+        end
+      else
+        raise "mode `#{mode.inspect}` is not defined"
+      end
+    end
+    
+    # :numeric_long      ...  3 feet 1 3/4 inches
+    # :numeric_short      ...  3ft 1 3/4in
+    # :descriptive  ... three feet one and three quarter inches
+    # :tics_utf     ... 3′ 1¾″
+    # :tics_html    ...  above with html codes
+    def self.inches_to_feet(flt, mode = :descriptive, denom=16)
+      neg = flt.negative? ? "-" : ""
+      str = neg        
+      flt = flt.abs
+      num = flt.floor
+      frac = flt - num
+      feet = (num / 12.0)
+      feet_flr = feet.floor
+      feet_frac = feet - feet_flr
+      inches = feet_frac * 12.0 + frac
+      # copy & paste
+      frac = Fraction(inches,denom).to_s(false).to_s
+      ary  = frac.split(' ')     
+      if [:tics_utf,:tics_html].include? mode
+        if mode == :tics_utf
+          inch_tic = '″'
+          foot_tic = '′'
+        else
+          inch_tic = '&#8243;'
+          foot_tic = '&#8242;'
+        end
+        if (feet_flr.zero?)
+          if 1==ary.count
+            return '0' + foot_tic if 0 == ary.first.to_i
+          end
+        else
+          str += feet_flr.zero? ? "" : "#{feet_flr}#{foot_tic} "
+        end        
+        
+        if 1==ary.count
+          return str + ary.first + inch_tic          
+        else
+          str += ary.first
+          utf = FRACTION_UTF[ary.last]
+          if utf.nil?
+            str += ' ' + ary.last + inch_tic
+          else
+            if mode == :tics_utf
+              str += utf + inch_tic
+            else
+              str += '&#' + "#{utf.ord};" + inch_tic
+            end
+          end  
+          return str        
+        end       
+      elsif [:numeric_long,:numeric_short].include? mode     
+        if mode == :numeric_short
+          inch_name = 'in'
+          foot_name = 'ft'
+        else
+          inch_name = ' inch'
+          foot_name = feet_flr==1 ? ' foot' : ' feet'
+        end
+        if feet_flr.zero?
+          if 1==ary.count
+            return '0' + foot_name if 0 == ary.first.to_i
+          end
+        else
+          str += feet_flr.to_s + foot_name
+        end
+        if 1==ary.count
+          str += ' ' unless str.empty?
+          str += ary.first + inch_name
+          if mode == :numeric_long
+            str += 'es' unless ary.first.to_i == 1
+          end
+        else
+          str += ' ' unless str.empty?
+          str += ary.first + ' ' + ary.last + inch_name
+          str += 'es' unless mode == :numeric_short          
+        end
+        return str              
+      elsif :descriptive == mode
+        inch_name = ' inch'
+        foot_name = feet_flr==1 ? ' foot' : ' feet'
+        str = "minas " unless str.empty?
+        if feet_flr.zero?
+          if 1==ary.count
+            return 'zero' + foot_name if '0' == ary.first
+          end
+        else
+          str += Nth::get_number_name(feet_flr, :-) + foot_name
+        end
+        if 1==ary.count
+          ### fractional entities must not call #to_i
+          ### ok unless fractional
+          if ary.first.include? '/'
+            ary = ary.first.split('/')
+            str += ' ' unless str.empty?
+            str += Nth::get_number_name(ary.first.to_i, :-) + ' ' + Nth::get_denominator_name(ary.last.to_i) + inch_name
+          else
+            str += ' ' unless str.empty?
+            str += Nth::get_number_name(ary.first.to_i, :-) + inch_name
+            str += 'es' unless ary.first == '1'
+          end
+        else
+          str += ' ' unless str.empty?
+          str += Nth::get_number_name(ary.first.to_i, :-) + ' and '
+          ary = ary.last.split('/')
+          str += Nth::get_number_name(ary.first.to_i, :-) + ' ' + Nth::get_denominator_name(ary.last.to_i) + inch_name + 'es'
+        end
+        return str                      
+      else
+        raise "unsupported mode #{mode}"
+      end
+    end
+    
+    # this would be nice on the fraction class too...
+    
+    def self.inches_to_yards(flt, mode = :descriptive, denom=16)
+      raise 'unsupported mode' unless [:numeric_long,:numeric_short,:descriptive].include? mode
+      # try to use inches_to_feet
+      neg = flt.negative? ? true : false
+      pfx = neg ? "-" : ""
+      flt = flt.abs
+      yards = (flt / 36.0).floor
+      inches = flt - (yards * 36.0)
+      str = inches_to_feet(inches, mode, denom)         
+      if yards==1
+        if :numeric_short==mode
+          return pfx + "1yd " + str
+        elsif :numeric_long==mode
+          return pfx + "1 yard " + str
+        else
+          pfx = "minas " if neg
+          return pfx + "one yard " + str  
+        end      
+      else
+        if :numeric_short==mode
+          return "#{yards}yd " + str
+        elsif :numeric_long==mode
+          return "#{yards} yards " + str
+        else
+          pfx = "minas " if neg
+          yy = Nth::get_number_name(yards, :-)
+          return "#{yy} yards " + str  
+        end      
+      end  
+    end
+    def self.to_dms(val, sec_frac=2)
+      sgn = val.negative? ? -1.0 : 1.0
+      num = val.abs % 360
+      num *= sgn
+      if num > 180.0
+        num -= 360.0
+      elsif num < -180.0
+        num += 360.0
+      end
+      sgn = num.negative? ? "-" : ""
+      num = num.abs
+      deg = num.floor
+      num = (num-deg) * 60.0
+      min = num.floor
+      num = (num-min) * 60.0
+      if (sec_frac==0)
+        sec = num.round 0
+        frac = ""
+      else
+        sec = num.floor
+        num = (num-sec) * (10 ** sec_frac)
+        frac = ".#{num.floor}"
+      end
+      return "#{sgn}#{deg}°#{min}′#{sec}#{frac}″"
+    end
+  end
+  
+  def self.install(pn = :None, *plist)
+    if    (pn==:IntMethods)
+      Integer.class_eval do
+        unless self.instance_methods.include? :nth
+          def nth(comma=true)
+            Nth::IntMethods.to_nth_string(self, comma)
+          end
+        end
+        unless self.instance_methods.include? :to_ordinal
+          def to_ordinal
+            Nth::IntMethods.to_ordinal_string(self)        
+          end
+        end
+        unless self.instance_methods.include? :to_number
+          def to_number
+            Nth::IntMethods.to_number_string(self)        
+          end
+        end  
+        unless self.instance_methods.include? :cents_to_dollars
+          def cents_to_dollars
+            Nth::IntMethods.penny_to_dollar(self)
+          end
+        end
+        unless self.instance_methods.include? :pence_to_pounds
+          def pence_to_pounds
+            Nth::IntMethods.pence_to_pound(self)
+          end
+        end
+      end
+      # add to wrapper classes ...
+      meths = [:nth, :to_ordinal, :to_number, :cents_to_dollars, :pence_to_pounds]
+      Int.bestow_methods(*meths)
+      Number.bestow_methods(*meths)
+      Datum.bestow_methods(*meths)
+    elsif (pn==:FloatMethods)
+      Float.class_eval do
+        unless self.instance_methods.include? :to_fractional_unit
+          def to_fractional_unit(unit_name, mode = :descriptive, tar=0.01)
+            Nth::FloatMethods.to_fractional_unit(self, unit_name, mode, tar)
+          end
+        end
+        unless self.instance_methods.include? :inches_to_feet
+          def inches_to_feet(mode = :descriptive, denom=16)
+            Nth::FloatMethods.inches_to_feet(self, mode, denom)
+          end
+        end
+        unless self.instance_methods.include? :inches_to_yards
+          def inches_to_yards(mode = :descriptive, denom=16)
+            Nth::FloatMethods.inches_to_yards(self, mode, denom)
+          end
+        end
+        unless self.instance_methods.include? :to_dms
+          def to_dms(sec_frac=2)
+            Nth::FloatMethods.to_dms(self, sec_frac)
+          end
+        end
+      end
+    elsif (pn==:AccessAllOrdinals)
+      plist[0].class_eval do
+        @default_insert = plist[1]
+        if @default_insert.nil?
+          if self==String
+            @default_insert = ' '
+          end
+        end
+        def respond_to_missing?(method_name, include_private = false)
+          begin
+            meth = method_name.to_s
+            str = meth[-1]=="=" ? meth[0..-2] : meth
+            num = Nth::ordinal_string_to_number(str)
+            return num.type_of? Integer
+          rescue
+            return false
+          end
+          return false
+        end
+        def method_missing(method_name, *prms, &block)
+          meth = method_name.to_s
+          num = nil
+          assign = false
+          str = ""
+          begin
+            if meth[-1]=="="
+              str = meth[0..-2]
+              assign = true
+            else
+              str = meth
+            end
+            num = Nth::ordinal_string_to_number(str)
+          rescue
+            super
+          end
+          super if num.nil?
+          if assign
+            if 1==prms.count
+              if num >= size
+                rpl = self.class.instance_variable_get :@default_insert
+                (size..(num-1)).each { |t| self[t] = rpl }
+              end
+              self[num] = prms[0]
+              return self
+            else
+              raise "*** ArgumentError Exception: wrong number of arguments (given #{prms.count}, expected 1)"
+            end
+          else
+            raise "*** ArgumentError Exception: wrong number of arguments (given #{prms.count}, expected 0)" if prms.count > 0
+            return self[num]
+          end          
+        end
+      end
+    elsif (pn==:AccessOrdinals)
+      plist[0].class_eval do
+        @default_insert = plist[2]
+        if @default_insert.nil?
+          if self==String
+            @default_insert = ' '
+          end
+        end
+        unless self.instance_methods.include? :last
+          def last
+            self[-1]
+          end
+        end
+        unless self.instance_methods.include? :last=
+          def last=(val)
+            self[-1]=val
+          end
+        end
+        ran = (1..plist[1])
+        ran.each do |num|
+          meth = Nth::get_ordinal_name(num, :_)
+          unless self.instance_methods.include? meth.to_sym
+            define_method meth.to_sym do
+              self[num-1]
+            end
+          end
+          meth += '='
+          unless self.instance_methods.include? meth.to_sym
+            define_method meth.to_sym do |val| 
+              if num >= size
+                rpl = self.class.instance_variable_get :@default_insert
+                (size..(num-1)).each { |t| self[t] = rpl }
+              end
+              self[num-1] = val
+              self
+            end
+          end    
+        end
+      end
+    else
+      raise "unrecognized install parameter #{pn}"  
     end
   end
 end