tolerances 1.0.0

data.tar.gz.sig

@@ -0,0 +1,3 @@
+z�?���X�M�NwC��^x2��t��'�=�:�_�Cd}�MfHa|�7nT�L�v����.��}���ʾ��g��8.0s$�Ɍx:y�;��<�|B{��
+�(��ݪ�1��|+JT٘ڊcJ
+��lr�u���bΣ�8��SCE�Vw�ף2Wv�Se�6

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-06-28
+
+* 1 major enhancement
+
+  * Birthday!
+

data/License.txt

@@ -0,0 +1,263 @@
+== LICENSE
+
+ NASA OPEN SOURCE AGREEMENT VERSION 1.3
+
+ THIS OPEN SOURCE AGREEMENT ("AGREEMENT") DEFINES THE RIGHTS OF USE,
+ REPRODUCTION, DISTRIBUTION, MODIFICATION AND REDISTRIBUTION OF CERTAIN
+ COMPUTER SOFTWARE ORIGINALLY RELEASED BY THE UNITED STATES GOVERNMENT
+ AS REPRESENTED BY THE GOVERNMENT AGENCY LISTED BELOW ("GOVERNMENT
+ AGENCY").  THE UNITED STATES GOVERNMENT, AS REPRESENTED BY GOVERNMENT
+ AGENCY, IS AN INTENDED THIRD-PARTY BENEFICIARY OF ALL SUBSEQUENT
+ DISTRIBUTIONS OR REDISTRIBUTIONS OF THE SUBJECT SOFTWARE.  ANYONE WHO
+ USES, REPRODUCES, DISTRIBUTES, MODIFIES OR REDISTRIBUTES THE SUBJECT
+ SOFTWARE, AS DEFINED HEREIN, OR ANY PART THEREOF, IS, BY THAT ACTION,
+ ACCEPTING IN FULL THE RESPONSIBILITIES AND OBLIGATIONS CONTAINED IN
+ THIS AGREEMENT.
+
+ Government Agency: NASA Langley Research Center
+ Government Agency Original Software Designation: LAR-17546-1
+ Government Agency Original Software Title: Tolerance DSL
+ User Registration Requested: please see clause 3.F.
+ Government Agency Point of Contact: please see clause 5.F at end.
+
+ 1. DEFINITIONS
+
+ A. "Contributor" means Government Agency, as the developer of the
+ Original Software, and any entity that makes a Modification.
+
+ B. "Covered Patents" mean patent claims licensable by a Contributor
+ that are necessarily infringed by the use or sale of its Modification
+ alone or when combined with the Subject Software.
+
+ C. "Display" means the showing of a copy of the Subject Software,
+ either directly or by means of an image, or any other device.
+
+ D. "Distribution" means conveyance or transfer of the Subject
+ Software, regardless of means, to another.
+
+ E. "Larger Work" means computer software that combines Subject
+ Software, or portions thereof, with software separate from the Subject
+ Software that is not governed by the terms of this Agreement.
+
+ F. "Modification" means any alteration of, including addition to or
+ deletion from, the substance or structure of either the Original
+ Software or Subject Software, and includes derivative works, as that
+ term is defined in the Copyright Statute, 17 USC 101.  However, the
+ act of including Subject Software as part of a Larger Work does not in
+ and of itself constitute a Modification.
+
+ G. "Original Software" means the computer software first released
+ under this Agreement by Government Agency with Government Agency
+ designation NASA and entitled fUnit, including source code,
+ object code and accompanying documentation, if any.
+
+ H. "Recipient" means anyone who acquires the Subject Software under
+ this Agreement, including all Contributors.
+
+ I. "Redistribution" means Distribution of the Subject Software after a
+ Modification has been made.
+
+ J. "Reproduction" means the making of a counterpart, image or copy of
+ the Subject Software.
+
+ K. "Sale" means the exchange of the Subject Software for money or
+ equivalent value.
+
+ L. "Subject Software" means the Original Software, Modifications, or
+ any respective parts thereof.
+
+ M. "Use" means the application or employment of the Subject Software
+ for any purpose.
+
+ 2. GRANT OF RIGHTS
+
+ A. Under Non-Patent Rights: Subject to the terms and conditions of
+ this Agreement, each Contributor, with respect to its own contribution
+ to the Subject Software, hereby grants to each Recipient a
+ non-exclusive, world-wide, royalty-free license to engage in the
+ following activities pertaining to the Subject Software:
+
+  1. Use
+  2. Distribution
+  3. Reproduction
+  4. Modification
+  5. Redistribution
+  6. Display
+
+ B. Under Patent Rights: Subject to the terms and conditions of this
+ Agreement, each Contributor, with respect to its own contribution to
+ the Subject Software, hereby grants to each Recipient under Covered
+ Patents a non-exclusive, world-wide, royalty-free license to engage in
+ the following activities pertaining to the Subject Software:
+
+  1. Use
+  2. Distribution
+  3. Reproduction
+  4. Sale
+  5. Offer for Sale
+
+ C. The rights granted under Paragraph B. also apply to the combination
+ of a Contributor's Modification and the Subject Software if, at the
+ time the Modification is added by the Contributor, the addition of
+ such Modification causes the combination to be covered by the Covered
+ Patents.  It does not apply to any other combinations that include a
+ Modification.
+
+ D. The rights granted in Paragraphs A. and B. allow the Recipient to
+ sublicense those same rights.  Such sublicense must be under the same
+ terms and conditions of this Agreement.
+
+ 3. OBLIGATIONS OF RECIPIENT
+
+ A. Distribution or Redistribution of the Subject Software must be made
+ under this Agreement except for additions covered under paragraph 3H.
+
+ 1. Whenever a Recipient distributes or redistributes the Subject
+     Software, a copy of this Agreement must be included with each copy
+     of the Subject Software; and
+
+ 2. If Recipient distributes or redistributes the Subject Software in
+     any form other than source code, Recipient must also make the
+     source code freely available, and must provide with each copy of
+     the Subject Software information on how to obtain the source code
+     in a reasonable manner on or through a medium customarily used for
+     software exchange.
+
+ B. Each Recipient must ensure that the following copyright notice
+ appears prominently in the Subject Software:
+
+  Copyright 2007-2008 United States Government as represented by
+  NASA Langley Research Center. No copyright is claimed in
+  the United States under Title 17, U.S. Code. All Other Rights
+  Reserved.
+
+ C. Each Contributor must characterize its alteration of the Subject
+ Software as a Modification and must identify itself as the originator
+ of its Modification in a manner that reasonably allows subsequent
+ Recipients to identify the originator of the Modification.  In
+ fulfillment of these requirements, Contributor must include a file
+ (e.g., a change log file) that describes the alterations made and the
+ date of the alterations, identifies Contributor as originator of the
+ alterations, and consents to characterization of the alterations as a
+ Modification, for example, by including a statement that the
+ Modification is derived, directly or indirectly, from Original
+ Software provided by Government Agency. Once consent is granted, it
+ may not thereafter be revoked.
+
+ D. A Contributor may add its own copyright notice to the Subject
+ Software.  Once a copyright notice has been added to the Subject
+ Software, a Recipient may not remove it without the express permission
+ of the Contributor who added the notice.
+
+ E. A Recipient may not make any representation in the Subject Software
+ or in any promotional, advertising or other material that may be
+ construed as an endorsement by Government Agency or by any prior
+ Recipient of any product or service provided by Recipient, or that may
+ seek to obtain commercial advantage by the fact of Government Agency's
+ or a prior Recipient's participation in this Agreement.
+
+ F. In an effort to track usage and maintain accurate records of the
+ Subject Software, each Recipient, upon receipt of the Subject Software,
+ is requested to provide Government Agency, by e-mail to the Government
+ Agency Point of Contact listed in clause 5.F., the following information:
+ name, institution (if applicable), postal code, and country.
+ Recipient's name and personal information shall be used for statistical
+ purposes only. Once a Recipient makes a Modification available, it is
+ requested that the Recipient inform Government Agency, by e-mail to the
+ Government Agency Point of Contact listed in clause 5.F., how to
+ access the Modification.
+
+ G. Each Contributor represents that that its Modification is believed
+ to be Contributor's original creation and does not violate any
+ existing agreements, regulations, statutes or rules, and further that
+ Contributor has sufficient rights to grant the rights conveyed by this
+ Agreement.
+
+ H. A Recipient may choose to offer, and to charge a fee for, warranty,
+ support, indemnity and/or liability obligations to one or more other
+ Recipients of the Subject Software.  A Recipient may do so, however,
+ only on its own behalf and not on behalf of Government Agency or any
+ other Recipient.  Such a Recipient must make it absolutely clear that
+ any such warranty, support, indemnity and/or liability obligation is
+ offered by that Recipient alone.  Further, such Recipient agrees to
+ indemnify Government Agency and every other Recipient for any
+ liability incurred by them as a result of warranty, support, indemnity
+ and/or liability offered by such Recipient.
+
+ I. A Recipient may create a Larger Work by combining Subject Software
+ with separate software not governed by the terms of this agreement and
+ distribute the Larger Work as a single product. In such case, the
+ Recipient must make sure Subject Software, or portions thereof,
+ included in the Larger Work is subject to this Agreement.
+
+ J. Notwithstanding any provisions contained herein, Recipient is
+ hereby put on notice that export of any goods or technical data from
+ the United States may require some form of export license from the
+ U.S. Government.  Failure to obtain necessary export licenses may
+ result in criminal liability under U.S. laws.  Government Agency
+ neither represents that a license shall not be required nor that, if
+ required, it shall be issued.  Nothing granted herein provides any
+ such export license.
+
+ 4. DISCLAIMER OF WARRANTIES AND LIABILITIES; WAIVER AND INDEMNIFICATION
+
+ A. No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY
+ WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY,
+ INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE
+ WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM
+ INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR
+ FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO
+ THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER,
+ CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT
+ OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY
+ OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE.
+ FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES
+ REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE,
+ AND DISTRIBUTES IT "AS IS."
+
+ B. Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS
+ AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND
+ SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT.  IF RECIPIENT'S USE OF
+ THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES,
+ EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM
+ PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT
+ SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED
+ STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY
+ PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.  RECIPIENT'S SOLE
+ REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL
+ TERMINATION OF THIS AGREEMENT.
+
+ 5. GENERAL TERMS
+
+ A. Termination: This Agreement and the rights granted hereunder will
+ terminate automatically if a Recipient fails to comply with these
+ terms and conditions, and fails to cure such noncompliance within
+ thirty (30) days of becoming aware of such noncompliance.  Upon
+ termination, a Recipient agrees to immediately cease use and
+ distribution of the Subject Software.  All sublicenses to the Subject
+ Software properly granted by the breaching Recipient shall survive any
+ such termination of this Agreement.
+
+ B. Severability: If any provision of this Agreement is invalid or
+ unenforceable under applicable law, it shall not affect the validity
+ or enforceability of the remainder of the terms of this Agreement.
+
+ C. Applicable Law: This Agreement shall be subject to United States
+ federal law only for all purposes, including, but not limited to,
+ determining the validity of this Agreement, the meaning of its
+ provisions and the rights, obligations and remedies of the parties.
+
+ D. Entire Understanding: This Agreement constitutes the entire
+ understanding and agreement of the parties relating to release of the
+ Subject Software and may not be superseded, modified or amended except
+ by further written agreement duly executed by the parties.
+
+ E. Binding Authority: By accepting and using the Subject Software
+ under this Agreement, a Recipient affirms its authority to bind the
+ Recipient to all terms and conditions of this Agreement and that that
+ Recipient hereby agrees to all terms and conditions herein.
+
+ F. Point of Contact: Any Recipient contact with Government Agency is
+ to be directed to the designated representative as follows:
+ Bil dot Kleb at NASA gov

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/quantiles.rb
+lib/simple_stats.rb
+lib/tolerance.rb
+lib/tolerances.rb
+test/test_quantiles.rb
+test/test_simple_stats.rb
+test/test_tolerance.rb
+test/test_tolerances.rb

data/README.txt

@@ -0,0 +1,41 @@
+= tolerances
+
+* http://rubyforge.org/projects/nasarb
+* http://nasarb.rubyforge.org/tolerances
+* mailto:nasarb-developers@rubyforge.org
+
+== DESCRIPTION:
+
+Provides a Tolerance object and a Tolerances collection to facilitate
+specifying and analyzing variabilities and uncertainties.
+
+To aid in sampling for Monte-Carlos applications, this package also
+includes some inverse cummulative probability distribution functions.
+
+== FEATURES/PROBLEMS:
+
+* Document uncertainties in situ with tolerance markup, e.g., 1.0+/-0.2
+* Can be used by Monte Carlos black box techniques for propogating
+  uncertainty intervals or computing sensitivities.
+
+== SYNOPSIS:
+
+  require 'rubygems'
+  require 'tolerances'
+
+  p Tolerance.parse("Uncertainty: 10+/-1")
+
+  #<Tolerance:0x52f788 @center=10.0, @distribution=nil, @format=nil,
+                       @halfwidth=1.0, @tag="untagged_1", @type=:raw>
+
+== REQUIREMENTS:
+
+* rubygems
+
+== INSTALL:
+
+* sudo gem install tolerances
+
+== LICENSE:
+
+Tolerance is released under the NASA Open Source Agreement -- see License.txt[link:files/License_txt.html] for details.

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/tolerances.rb'
+
+Hoe.new('tolerances', Tolerances::VERSION) do |p|
+  p.rubyforge_name  = 'nasarb'
+  p.remote_rdoc_dir = 'tolerances'
+  p.developer('Bil Kleb', 'Bil.Kleb@nasa.gov')
+  p.rsync_args = '-rpv --delete' # to perserve group permissions
+end
+
+# vim: syntax=Ruby

data/lib/quantiles.rb

@@ -0,0 +1,57 @@
+module Quantiles
+
+  # approximation from Peter J. Acklam
+  def normal(p)
+    (Float::EPSILON..1-Float::EPSILON).include? p or
+      raise "#{p}: outside probabiliy domain (0,1)"
+    a = [ -3.969683028665376e+01,  2.209460984245205e+02,
+          -2.759285104469687e+02,  1.383577518672690e+02,
+          -3.066479806614716e+01,  2.506628277459239e+00 ]
+    b = [ -5.447609879822406e+01,  1.615858368580409e+02,
+          -1.556989798598866e+02,  6.680131188771972e+01,
+          -1.328068155288572e+01 ]
+    c = [ -7.784894002430293e-03, -3.223964580411365e-01,
+          -2.400758277161838e+00, -2.549732539343734e+00,
+           4.374664141464968e+00,  2.938163982698783e+00 ]
+    d = [  7.784695709041462e-03,  3.224671290700398e-01,
+           2.445134137142996e+00,  3.754408661907416e+00 ]
+    if p < 0.02425 then # lower region
+      q = Math.sqrt(-2*Math.log(p))
+      (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
+       ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
+    elsif p < 0.97575 then # central region (symmetrical)
+      q = p - 0.5
+      r = q*q
+      (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q /
+      (((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1)
+    else # upper region
+      q = Math.sqrt(-2*Math.log(1-p))
+      -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
+        ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
+    end
+  end
+  module_function :normal
+
+  def uniform(p)
+    (0..1).include? p or raise "#{p}: outside probability domain [0,1]"
+    p-0.5
+  end
+  module_function :uniform
+
+  def triangular(p)
+    (0..1).include? p or raise "#{p}: outside probability domain [0,1]"
+    if p < 0.5
+      -0.5 + Math.sqrt( 0.5*p )
+    else # symmetric reflection
+       0.5 - Math.sqrt( 0.5*(1-p) )
+    end
+  end
+  module_function :triangular
+
+  def cauchy(p)
+    (0..1).include? p or raise "#{p}: outside probability domain [0,1]"
+    Math.tan(Math::PI*(0.5-p))
+  end
+  module_function :cauchy
+
+end

data/lib/simple_stats.rb

@@ -0,0 +1,102 @@
+##
+# Statistical methods to be used with numeric Arrays
+
+module SimpleStats
+
+  def mean
+    self.inject(0) { |sum, x| sum + x.to_f / self.size }
+  end
+
+  def median
+    sorted = self.sort
+    mid = sorted.size / 2
+    sorted.size % 2 == 0 ? [ sorted[mid], sorted[mid-1] ].mean : sorted[mid]
+  end
+
+  def variance
+    mean = self.mean
+    self.inject(0) { |sum, x| sum + (x-mean)**2 } / self.size 
+  end
+
+  def standard_deviation
+    Math::sqrt(self.variance)
+  end
+
+  def coefficient_of_variation
+    mean = self.mean
+    mean == 0 ? 0.0 : self.standard_deviation/mean
+  end
+
+  def skewness
+    mean, variance = self.mean, self.variance
+    variance == 0 ? 0.0 :
+      self.inject(0) { |sum, x| sum + (x-mean)**3 } /
+      self.size / variance**(3/2.0)
+  end
+
+  def kurtosis
+    mean, variance = self.mean, self.variance
+    variance == 0 ? 0.0 :
+      self.inject(0) { |sum, x| sum + (x-mean)**4 } /
+      self.size / variance**2
+  end
+
+  def percentile(percentage)
+    self.sort[ (self.size-1)*percentage/100 + 0.5 ]
+  end
+
+  def histogram(num_of_bins=20)
+    min, max = self.min, self.max
+    bin_width = Float(max-min)/num_of_bins
+    bins = []
+    num_of_bins.times do
+      bins << (min..min+bin_width)
+      min += bin_width
+    end
+    histohash = {}
+    bins.each{ |b| histohash[b]=0 }
+    self.each do |e|
+      bin = bins.find{ |b| b.include? e }
+      bin = bins.last unless bin # round off
+      histohash[ bin ] += 1
+    end
+    histohash.sort do |x,y|
+      0.5*(x[0].begin+x[0].end) <=> 0.5*(y[0].begin+y[0].end)
+    end
+  end
+
+  def within?(tolerance,options={})
+    last_value = self.last
+    max_difference = self.inject(0) do |max,value|
+      difference = ( last_value - value ).abs
+      max >= difference ? max : difference
+    end
+    scale = options[:percent] ? 100.0/last_value : 1
+    scale = 0 if scale == 1.0/0
+    max_difference * scale <= tolerance
+  end
+
+end
+
+##
+# Sample usage, complete with ASCII histogram plot
+
+if __FILE__ == $0 then
+  require 'quantiles'
+  class Array; include SimpleStats; end
+  N = 10000
+  samples = []
+  (1..N).each{ |i| samples << QuantileFunctions.normal(0.5) }
+  puts "           samples: #{N}"
+  puts "             range: #{samples.min}...#{samples.max}"
+  puts "              mean: #{samples.mean}"
+  puts "            median: #{samples.median}"
+  puts "standard deviation: #{samples.standard_deviation}"
+  puts "          skewness: #{samples.skewness}"
+  puts "          kurtosis: #{samples.kurtosis}"
+  bins = Hash.new{ |h,k| h[k]=0 }
+  samples.each{ |s| bins[((s*10).round/10.0).to_s] += 1 }
+  bins.to_a.sort{ |x,y| x[0].to_f <=> y[0].to_f }.each do |pair|
+    puts pair.first.to_s.rjust(4) + " " + "*" * ( pair.last.to_f * 800 / N )
+  end
+end

data/lib/tolerance.rb

@@ -0,0 +1,99 @@
+require 'scanf'
+require 'quantiles'
+
+class Tolerance
+
+  DEFAULTS = { :type=>:raw, :quantile=>nil, :format=>nil, :tag=>nil }
+
+  FLOAT = /[-+]*(?=\d|\.\d)\d*(?:\.\d*)?(?:[eE][-+]\d+)*/
+
+  REGEX = /(#{FLOAT})            # $1 : number
+           \s*\+\/-\s*
+           (#{FLOAT})            # $2 : tolerance
+           (%|o)?                # $3 : type of tolerance (optional)
+           (U|N|I|T)?            # $4 : quantile sampling function (optional)
+           (?:_(\d?[.]?\d*[#{Scanf::FormatString::SPECIFIERS}]))?
+                                 # $5 : format specifier (optional)
+           (?:\s*(["'])(.*?)\6)? # $7 : tag (funky stuff is "-matching)
+          /x
+
+  @@untagged = 0
+
+  attr_reader :center, :halfwidth
+  attr_reader :type, :quantile, :format, :tag
+  attr_accessor :sample_index
+
+  def initialize( center, halfwidth, options={} ) 
+    @center, @halfwidth = center.to_f, halfwidth.to_f
+    set_options DEFAULTS.merge(options)
+  end
+
+  def self.parse(string)
+    tolerances = []
+    string.scan(REGEX).each do |ctr, width, type, quantile, format, _, tag|
+      tolerances <<
+        Tolerance.new( ctr, width, :type   => type, :quantile => quantile,
+                                   :format => format,    :tag => tag )
+    end
+    case tolerances.size
+    when 0: nil
+    when 1: tolerances[0]
+    else    tolerances
+    end
+  end
+
+  def value_at( halfwidth_fraction )
+    case type
+    when :raw then
+      @center + halfwidth_fraction*@halfwidth
+    when :percent then
+      @center + halfwidth_fraction*@center*(@halfwidth/100)
+    when :order then
+      if @center < 0 then
+        -10**( log10(-@center) + halfwidth_fraction*@halfwidth )
+      elsif @center > 0 then
+         10**( log10( @center) + halfwidth_fraction*@halfwidth )
+      else # necessary for Ruby < 1.8.6
+         0
+      end
+    end
+  end
+
+  def self.untagged=(index)
+    @@untagged = index
+  end
+
+  private
+
+  def set_options(options)
+    @type = set_type options[:type]
+    @quantile = set_quantile options[:quantile]
+    @format = options[:format]
+    @tag = options[:tag] || "untagged_#{@@untagged+=1}"
+  end
+
+  def set_type( type )
+    case type
+    when 'o' then :order
+    when '%' then :percent 
+    when nil then DEFAULTS[:type]
+    when :raw,:order,:percent then type
+    else
+      raise "unknown tolerance type: >>#{type}<<"
+    end
+  end
+
+  def set_quantile( quantile )
+    case quantile
+    when 'U' then :uniform
+    when 'N' then :normal
+    when 'I' then :interval
+    when 'T' then :triangular
+    when nil then DEFAULTS[:quantile]
+    when :uniform,:normal,:interval,:triangular then quantile
+    else
+      raise "unknown tolerance quantile: >>#{quantile}<<"
+    end
+  end
+
+end

data/lib/tolerances.rb

@@ -0,0 +1,60 @@
+require 'tolerance'
+
+class Tolerances
+
+  VERSION = '1.0.0'
+
+  attr_reader :tolerances, :tags
+
+  def initialize( contents )
+    @contents = contents
+    @tolerances = []
+    @template = ''
+    @tags = Hash.new{ |h,k| h[k]=[] }
+    find_tolerances
+    create_template
+    collect_tags
+  end
+
+  class << self
+    alias parse new
+  end
+
+  def values_at( samples )
+    if samples.size != tags.size
+      raise "samples (#{samples.size}) != tags (#{@tags.size})"
+    end
+    values = []
+    @tolerances.each_with_index do |tol,i|
+      values << tol.value_at( samples[tol.sample_index] )
+    end
+    values
+  end
+
+  def result( values )
+    @template % values
+  end
+
+  private
+
+  def create_template
+    @template = @contents.gsub(Tolerance::REGEX) do
+      $5 ? "%#$5" : '%s'
+    end
+  end
+
+  def find_tolerances
+    @tolerances = [Tolerance.parse(@contents)].flatten.compact
+  end
+
+  def collect_tags
+    sample_index = -1
+    @tolerances.each do |tolerance|
+      sample_index +=1 unless tags.keys.include? tolerance.tag
+      tolerance.sample_index = sample_index
+      tags[tolerance.tag] << tolerance
+    end
+    self
+  end
+
+end

data/test/test_quantiles.rb

@@ -0,0 +1,99 @@
+require 'test/unit'
+require 'simple_stats'
+require 'quantiles'
+
+class Array # mixin statistical functions
+  include SimpleStats
+end
+
+class TestQuantiles < Test::Unit::TestCase
+
+  include Quantiles
+
+  def setup
+    srand 1234
+  end
+
+# Normal quantile
+
+  def test_normal_quantile_domain_checking
+    assert_nothing_thrown{normal(Float::EPSILON)}
+    assert_raises(RuntimeError){normal(0)}
+    assert_raises(RuntimeError){normal(1)}
+    assert_nothing_thrown{normal(1-Float::EPSILON)}
+  end
+  def test_normal_quantile_at_specific_values
+    assert_in_delta( -4.264890795, normal(0.00001), 1e-9 )
+    assert_in_delta( -0.674489750, normal(0.25000), 1e-9 )
+    assert_in_delta(  0.0,         normal(0.50000), 1e-9 )
+    assert_in_delta(  0.674489750, normal(0.75000), 1e-9 )
+    assert_in_delta(  4.264890795, normal(0.99999), 1e-9 )
+  end
+  def test_normal_quantile_nominal_statistics
+    samples = []
+    1000.times{ samples << normal(rand) }
+    assert_in_delta( 0.0, samples.mean,               0.05, "mean" )
+    assert_in_delta( 0.0, samples.median,             0.10, "median" )
+    assert_in_delta( 1.0, samples.standard_deviation, 0.05, "sigma" )
+    assert_in_delta( 0.0, samples.skewness,           0.10, "skewness" )
+    assert_in_delta( 3.0, samples.kurtosis,           0.10, "kurtosis" )
+  end
+  def test_normal_quantile_specified_sigma_statistics
+    samples = []
+    1000.times{ samples << 0.2*normal(rand) }
+    assert_in_delta( 0.0, samples.mean,               0.05, "mean" )
+    assert_in_delta( 0.0, samples.median,             0.05, "median" )
+    assert_in_delta( 0.2, samples.standard_deviation, 0.05, "sigma" )
+    assert_in_delta( 0.0, samples.skewness,           0.10, "skewness" )
+    assert_in_delta( 3.0, samples.kurtosis,           0.10, "kurtosis" )
+  end
+
+# Uniform quantile
+
+  def test_uniform_quantile_nominal_range
+    100.times { assert_in_delta( 0.0, uniform(rand), 0.5 ) }
+  end
+  def test_uniform_quantile_specified_width
+    100.times { assert_in_delta( 0.0, 1.0*2*uniform(rand), 1) }
+  end
+  def test_uniform_quantile_specified_0p4_fractional_width_range
+    100.times { assert_in_delta( 0.0, 0.4*2*uniform(rand), 0.4 ) }
+  end
+  def test_uniform_quantile_statistics
+    samples = []
+    1000.times{ samples << uniform(rand) }
+    assert_in_delta( 0.0,    samples.mean,     0.01, "mean" )
+    assert_in_delta( 0.0,    samples.median,   0.05, "median" )
+    assert_in_delta( 1/12.0, samples.variance, 0.05, "sigma" )
+    assert_in_delta( 0.0,    samples.skewness, 0.10, "skewness" )
+    assert_in_delta( 9/5.0,  samples.kurtosis, 0.05, "kurtosis" )
+  end
+
+# Triangular quantile
+
+  def test_triangular_quantile_nominal_range
+    100.times { assert_in_delta( 0.0, triangular(rand), 0.5 ) }
+  end
+  def test_triangular_quantile_specified_halfwidth
+    100.times { assert_in_delta( 0.0, 1.0*2*triangular(rand), 1.0 ) }
+  end
+  def test_triangular_quantile_specified_fractional_width_range
+    100.times { assert_in_delta( 0.0, 0.2*2*triangular(rand), 0.2 ) }
+  end
+  def test_triangular_quantile_statistics
+    samples = []
+    1000.times { samples << triangular(rand) }
+    assert_in_delta( 0.0,    samples.mean,     0.010, "mean" )
+    assert_in_delta( 0.0,    samples.median,   0.020, "median" )
+    assert_in_delta( 3/72.0, samples.variance, 0.005, "variance" )
+    assert_in_delta( 0.0,    samples.skewness, 0.050, "skewness" )
+    assert_in_delta( 2.4,    samples.kurtosis, 0.050, "kurtosis" )
+  end
+
+# Cauchy quantile
+
+  def test_cauchy_quantile_function_with_known_values
+    assert_equal 0, cauchy(0.5)
+  end
+
+end

data/test/test_simple_stats.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'simple_stats'
+
+# FIXME: no monkey patching please
+class Array # mixin statistics
+  include SimpleStats
+end
+
+class TestArrayStatistics < Test::Unit::TestCase
+
+  def test_median
+    assert_equal(0, [0].median)
+    assert_equal(1, [1].median)
+    assert_equal(0.5, [0,1].median)
+    assert_equal(0.5, [0,1.0].median)
+    assert_equal(1, [0,2].median)
+    assert_equal(1, [0,1,2].median)
+  end
+
+  def test_mean
+    assert_equal(0, [0].mean)
+    assert_equal(0.5, [0,1].mean)
+    assert_equal(0.5, [0,1.0].mean)
+    assert_equal(0.5, [0.0,0.25,0.50,0.75,1.0].mean)
+  end
+
+  def test_variance
+    assert_equal(0, [0].variance)
+    assert_equal((0.25+0.25)/2, [0,1].variance)
+  end
+
+  def test_standard_deviation
+    assert_equal(0, [0].standard_deviation)
+    assert_equal(Math::sqrt((0.25+0.25)/2), [0,1].standard_deviation)
+  end
+
+  def test_coefficient_of_variation
+    assert_equal(0, [0].coefficient_of_variation)
+    assert_equal(Math.sqrt(0.25)/0.5, [0,1].coefficient_of_variation)
+  end
+
+  def test_skewness
+    assert_equal(0, [0].skewness)
+    assert_equal(0, [0,2].skewness)
+  end
+
+  def test_kurtosis
+    assert_equal(0, [0].kurtosis)
+    assert_equal(1, [0,2].kurtosis)
+  end
+
+  def test_histogram
+    histo = [-3,-1,0,0,4,3,2].histogram(7)
+    assert_equal( 7, histo.size )
+    assert_equal( 2, histo[2].last)
+  end
+
+  def test_percentile
+    samples = (1..10).to_a
+    assert_equal(  1, samples.percentile(0)    )
+    assert_equal(  1, samples.percentile(2.5)  )
+    assert_equal(  1, samples.percentile(10)   )
+    assert_equal(  2, samples.percentile(20)   )
+    assert_equal(  5, samples.percentile(50)   )
+    assert_equal(  8, samples.percentile(80)   )
+    assert_equal( 10, samples.percentile(97.5) )
+    assert_equal( 10, samples.percentile(100)  )
+    samples = [ 2, 3, 1, 4, 5 ]
+    assert_equal( 3, samples.percentile(50) )
+  end
+
+  def test_within?
+    samples = [ 3, 2, 1, 1, 1 ]
+    assert( samples.last(3).within?(0) )
+    assert( samples.last(4).within?(1) )
+    assert( samples.within?(2) )
+    assert( !samples.within?(1) )
+  end
+
+  def test_within_percent
+    samples = [ 3, 2, 1, 1, 1 ]
+    assert( samples.last(3).within?(0,:percent=>true) )
+    assert( samples.last(4).within?(100,:percent=>true) )
+    assert( samples.within?(200,:percent=>true) )
+    assert( !samples.within?(100,:percent=>true) )
+    samples = [ 2, 1, 0, 0, 0 ]
+    assert( samples.last(3).within?(0, :percent=>true) )
+  end
+
+end

data/test/test_tolerance.rb

@@ -0,0 +1,166 @@
+require 'test/unit'
+require 'tolerance'
+
+class TestTolerance < Test::Unit::TestCase
+  def setup
+    Tolerance.untagged = 0
+  end
+  def test_should_create_vanilla_tolerance_with_only_center_and_halfwidth
+    tol = Tolerance.new 5, 1
+    assert_equal 5, tol.center
+    assert_equal 1, tol.halfwidth
+    assert_equal :raw, tol.type
+    assert_nil tol.quantile
+    assert_nil tol.format
+    assert_equal 'untagged_1', tol.tag
+  end
+  def test_should_accept_specified_quantile
+    tol = Tolerance.new 5, 1, :quantile => :normal
+    assert_equal :normal, tol.quantile
+    tol = Tolerance.new 5, 1, :quantile => 'N'
+    assert_equal :normal, tol.quantile
+  end
+  def test_should_allow_tag_assignment
+    tol = Tolerance.new 5, 1, :tag => 'tag'
+    assert_equal 'tag', tol.tag
+  end
+  def test_should_allow_percent_type
+    tol = Tolerance.new 5, 50, :type => :percent
+    assert_equal :percent, tol.type
+    tol = Tolerance.new 5, 50, :type => '%'
+    assert_equal :percent, tol.type
+  end
+  def test_should_allow_order_type
+    tol = Tolerance.new 5, 1, :type => 'o'
+    assert_equal :order, tol.type
+    tol = Tolerance.new 5, 1, :type => :order
+    assert_equal :order, tol.type
+  end
+  def test_should_allow_uniform_quantile
+    tol = Tolerance.new 5, 1, :quantile => "U"
+    assert_equal :uniform, tol.quantile
+    tol = Tolerance.new 5, 1, :quantile => :uniform
+    assert_equal :uniform, tol.quantile
+  end
+  def test_should_have_uniform_and_tag
+    tol = Tolerance.new 0.7, 0.25, :quantile => "U", :tag => 'tag'
+    assert_equal 0.7, tol.center
+    assert_equal 0.25, tol.halfwidth
+    assert_equal :uniform, tol.quantile
+    assert_equal 'tag', tol.tag
+  end
+  def test_should_set_percent_type_and_uniform_quantile
+    tol = Tolerance.new 5, 50, :type => "%", :quantile => "U"
+    assert_equal :percent, tol.type
+    assert_equal :uniform, tol.quantile
+  end
+  def test_should_set_order_type_and_uniform_quantile
+    tol = Tolerance.new 5, 1, :type => "o", :quantile => "U"
+    assert_equal :order, tol.type
+    assert_equal :uniform, tol.quantile
+  end
+  def test_should_set_raw_type_with_triangular_quantile
+    tol = Tolerance.new 5, 1, :quantile => "T"
+    assert_equal :raw, tol.type
+    assert_equal :triangular, tol.quantile
+  end
+  def test_should_sample_at_center_point
+    tol = Tolerance.new 5, 1
+    assert_equal 5, tol.value_at(0)
+  end
+  def test_should_parse_a_single_tolerance
+    tol = Tolerance.parse '5+/-1'
+    assert_equal 5, tol.center
+    assert_equal 1, tol.halfwidth
+  end
+  def test_should_parse_more_than_one_tolerance
+    tols = Tolerance.parse '5+/-1 10+/-1'
+    assert_equal 2, tols.size
+  end
+  def test_should_return_nil_if_no_tolerances_found_during_parse
+    tol = Tolerance.parse ''
+    assert_nil tol
+  end
+  def test_integer_tolerance
+    tol = Tolerance.parse '5+/-1'
+    assert_equal 5, tol.center
+    assert_equal 1, tol.halfwidth
+  end
+  def test_float_tolerance
+    tol = Tolerance.parse '5.1+/-1.2'
+    assert_equal 5.1, tol.center
+    assert_equal 1.2, tol.halfwidth
+  end
+  def test_exponential_tolerance
+    tol = Tolerance.parse '5.1e+01+/-1.2'
+    assert_equal 5.1e+01, tol.center
+    assert_equal 1.2, tol.halfwidth
+  end
+  def test_tolerance_with_format
+    tol = Tolerance.parse '1.35+/-0.2_4.2f'
+    assert_equal '4.2f', tol.format
+  end
+  def test_tolerance_with_single_quoted_tag
+    tol = Tolerance.parse "5+/-1 'tag'"
+    assert_equal 'tag', tol.tag
+  end
+  def test_should_allow_no_space_between_tag_and_tolerance
+    tol = Tolerance.parse "5+/-1'tag'"
+    assert_equal 1, tol.halfwidth
+    assert_equal 'tag', tol.tag
+  end
+  def test_tolerance_with_double_quoted_tag_with_single_quote
+    tol = Tolerance.parse '5+/-1 "mix\'d"'
+    assert_equal "mix\'d", tol.tag
+  end
+  def test_tolerance_with_more_general_tag
+    tol = Tolerance.parse "5+/-1 'tag^2_2+3->4*1.0'"
+    assert_equal 'tag^2_2+3->4*1.0', tol.tag
+  end
+  def test_tolerance_with_more_general_tag_followed_by_single_quote
+    tol = Tolerance.parse "5+/-1 'tag' I'm here"
+    assert_equal 'tag', tol.tag
+  end
+  def test_tolerance_with_leading_debris
+    tol = Tolerance.parse "exp1 = 0.7+/-0.25U 'Eta_O2'"
+    assert_equal 0.7, tol.center
+  end
+  def test_tolerance_with_trailing_debris
+    tol = Tolerance.parse "0.7+/-0.25U 'Eta_O2' and things"
+    assert_equal 'Eta_O2', tol.tag
+  end
+  def test_percentage_tolerance
+    tol = Tolerance.parse "5+/-1%"
+    assert_equal :percent, tol.type
+  end
+  def test_zero_padded_percentage_tolerance
+    tol = Tolerance.parse "5+/-03%"
+    assert_equal 3, tol.halfwidth
+    assert_equal :percent, tol.type
+  end
+  def test_order_tolerance
+    tol = Tolerance.parse "5+/-1o"
+    assert_equal :order, tol.type
+  end
+  def test_tolerance_with_normal_quantile
+    tol = Tolerance.parse "5+/-1N"
+    assert_equal :normal, tol.quantile
+  end
+  def test_tolerance_with_uniform_quantile
+    tol = Tolerance.parse "5+/-1U"
+    assert_equal :uniform, tol.quantile
+  end
+  def test_tolerance_with_triangular_quantile
+    tol = Tolerance.parse "2+/-0.5T"
+    assert_equal :triangular, tol.quantile
+  end
+  def test_tolerance_with_only_interval
+    tol = Tolerance.parse "2+/-0.5I"
+    assert_equal :interval, tol.quantile
+  end
+  def test_order_tolerance_with_normal_quantile
+    tol = Tolerance.parse "5+/-1oN"
+    assert_equal :order, tol.type
+    assert_equal :normal, tol.quantile
+  end
+end

data/test/test_tolerances.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'tolerances'
+
+class TestTolerances < Test::Unit::TestCase
+  def setup
+    Tolerance.untagged = 0
+  end
+  def test_should_find_simple_tolerance
+    tols = Tolerances.parse('1+/-0.1')
+    assert_equal 1, tols.tolerances.size
+    tol = tols.tolerances.first
+    assert_equal 1,    tol.center
+    assert_equal 0.1,  tol.halfwidth
+    assert_equal :raw, tol.type
+    assert_nil tol.quantile
+    assert_nil tol.format
+    assert_equal 'untagged_1', tol.tag
+  end
+  def test_should_find_two_tolerances_on_same_line
+    tols = Tolerances.parse('1+/-0.1 2+/-0.1')
+    assert_equal 2, tols.tolerances.size
+  end
+  def test_should_find_groups_of_tags
+    tols = Tolerances.parse('1+/-0.1 "group" 2+/-0.1 "group"')
+    assert_equal 2, tols.tags['group'].size
+  end
+  def test_should_return_interpolated_string_with_values
+    tols = Tolerances.parse('2+/-0.1 x 4+/-0.1')
+    assert_equal '2.0 x 4.0', tols.result(tols.values_at([0,0]))
+  end
+  def test_should_return_interpolated_string_with_formatted_values
+    tols = Tolerances.parse('2+/-0.1_4.1f x 4+/-0.1_.3f')
+    assert_equal ' 2.0 x 4.000', tols.result(tols.values_at([0,0]))
+  end
+  def test_should_sample_according_to_specified_halfwidth_fraction
+    tols = Tolerances.parse('1+/-0.1')
+    assert_equal [1.0], tols.values_at([ 0])
+    assert_equal [1.1], tols.values_at([ 1])
+    assert_equal [0.9], tols.values_at([-1])
+  end
+  def test_should_fail_if_samples_and_tags_not_same_size
+    tols = Tolerances.parse('1+/-0.1')
+    assert_raises(RuntimeError){tols.values_at([])}
+  end
+  def test_should_sample_per_tag_according_to_specified_halfwidth_fraction
+    tols = Tolerances.parse('1+/-0.1 "DUP_TAG" 2+/-0.2 "DUP_TAG"')
+    assert_equal [ 1.0, 2.0 ], tols.values_at([ 0])
+    assert_equal [ 1.1, 2.2 ], tols.values_at([ 1])
+    assert_equal [ 0.9, 1.8 ], tols.values_at([-1])
+    tols = Tolerances.parse('1+/-0.1 2+/-0.2')
+    assert_equal [ 1.0, 1.8 ], tols.values_at([0,-1])
+    assert_equal [ 1.1, 2.0 ], tols.values_at([1, 0])
+    assert_equal [ 1.1, 1.8 ], tols.values_at([1,-1])
+  end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: tolerances
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Bil Kleb
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMDCCAhigAwIBAgIBADANBgkqhkiG9w0BAQUFADA+MREwDwYDVQQDDAhfaWwu
+  X2xlYjEUMBIGCgmSJomT8ixkARkWBG5hc2ExEzARBgoJkiaJk/IsZAEZFgNnb3Yw
+  HhcNMDgwNjI4MTUzNDQ4WhcNMDkwNjI4MTUzNDQ4WjA+MREwDwYDVQQDDAhfaWwu
+  X2xlYjEUMBIGCgmSJomT8ixkARkWBG5hc2ExEzARBgoJkiaJk/IsZAEZFgNnb3Yw
+  ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfYLFuBq7r82ByFeDxO8tN
+  Jlj48V/gDge4O3GA8ixGNIAYm3f1WZ9Y/I5wVPgdTLbtx6bzoxxsbWSxDBjEQfPc
+  A3tw3SaDBf6e3fZKulvWnZfQRFXykuVqsNDVN6Gptuz6AkKSZSxjBL+qva8+9PPB
+  tFjwsjHTwSZJoKQascjDr7lwdDZjQJD1PIzXNoN1wtGhungmD2T1ILKyNHuh/qr5
+  BQcfYrinKg9IbxJ0+rG5k5l6/0ybNp9G982+QE5JORENHcriCkVn8OoJHJpfuO+o
+  Zf4P0nTq9bM7cXLJBlnxBcb9Kj06o6583rtpL/H6wdnDuUMtBZ2QyENBfbSYGo9H
+  AgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSksDR+
+  lQd7lJO74TFtKv/cIHPaHDANBgkqhkiG9w0BAQUFAAOCAQEAKUaF/Yk4Y44D8/zD
+  4aee+CHm/gIQQfpvoAsSqDOBFIQibegx3c5GmNuc5JOK04Jp0oNt0I0EjTJhlbwO
+  HM5YQKNOXzRYW+E0FRqgExGkXa1BXSSglPo3GDSXHGMEUXUOCxanxzzJQPxL/wvR
+  sQfMNhZ0YmPB9slt+jzcEP0IWmV4Dwy83DdkPQjEh+mKvjmFRFqcwI3bYWYvALTF
+  t43RKq41H2ZFHxJTMGEOjzLYNkbsntV+XjrV8CMvJUs2X9aF/iCNpWr4AGIfglyC
+  EoMJU0ZoSzyJuoa35pscBdI6j7mzIDMX22WAsmR+S5ktzq4Bdn+Vmhk+EIZGkZ3I
+  55z1bA==
+  -----END CERTIFICATE-----
+
+date: 2008-07-03 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+    version: 
+description: Provides a Tolerance object and a Tolerances collection to facilitate specifying and analyzing variabilities and uncertainties.  To aid in sampling for Monte-Carlos applications, this package also includes some inverse cummulative probability distribution functions.
+email: 
+- Bil.Kleb@nasa.gov
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/quantiles.rb
+- lib/simple_stats.rb
+- lib/tolerance.rb
+- lib/tolerances.rb
+- test/test_quantiles.rb
+- test/test_simple_stats.rb
+- test/test_tolerance.rb
+- test/test_tolerances.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/nasarb
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: nasarb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Provides a Tolerance object and a Tolerances collection to facilitate specifying and analyzing variabilities and uncertainties
+test_files: 
+- test/test_quantiles.rb
+- test/test_simple_stats.rb
+- test/test_tolerance.rb
+- test/test_tolerances.rb