Boost-Commit :

Subject: [Boost-commit] svn:boost r80870 - in sandbox/SOC/2007/quan: . boost boost/quan boost/quan/impl libs libs/quan libs/quan/doc libs/quan/doc/doxygen libs/quan/example libs/quan/example/quan_simple libs/quan/test
From: pbristow_at_[hidden]
Date: 2012-10-05 10:48:19

• Next message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r80871 - in website/public_html/live: generated generated/state users/history"
• Previous message: pbristow_at_[hidden]: "[Boost-commit] svn:boost r80869 - sandbox/SOC/2007/visualization/libs/svg_plot/example"

Author: pbristow
Date: 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
New Revision: 80870
URL: http://svn.boost.org/trac/boost/changeset/80870

Log:
New quan package for type unc encoding uncertainty requires by visualization SVG_plot package.
Added:
   sandbox/SOC/2007/quan/
   sandbox/SOC/2007/quan/boost/
   sandbox/SOC/2007/quan/boost/quan/
   sandbox/SOC/2007/quan/boost/quan/impl/
   sandbox/SOC/2007/quan/boost/quan/impl/meas.ipp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/impl/unc.ipp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/impl/unc_input.ipp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/impl/unc_output.ipp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/impl/xiostream.ipp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/meas.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/meas2.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/pair_io.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/rounding.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/si_units.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/type_erasure_printer.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/unc.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/unc_init.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/uncbools.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/uncdata.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/uncs.hpp (contents, props changed)
   sandbox/SOC/2007/quan/boost/quan/xiostream.hpp (contents, props changed)
   sandbox/SOC/2007/quan/libs/
   sandbox/SOC/2007/quan/libs/quan/
   sandbox/SOC/2007/quan/libs/quan/doc/
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/draft.png (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/draft.svg (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/important.png (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/proposed_for_boost.png (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxyfile.txt (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxygen.css (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxygen_footer.html (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxygen_header.html (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/example/
   sandbox/SOC/2007/quan/libs/quan/example/quan_simple/
   sandbox/SOC/2007/quan/libs/quan/example/quan_simple/quan_simple.cpp (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/test/
   sandbox/SOC/2007/quan/libs/quan/test/Quan1In.txt (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/test/TestQuan1.cpp (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/test/test_rounding.cpp (contents, props changed)
   sandbox/SOC/2007/quan/libs/quan/test/unc_tests.cpp (contents, props changed)

Added: sandbox/SOC/2007/quan/boost/quan/impl/meas.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/impl/meas.ipp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,485 @@
+/*! \file
+ \brief Class for measurement using uncertain class - definitions.
+ \details class meas with UReal and measurement ID, order & time.
+*/
+
+// meas.ipp
+// Copyright Paul A. Bristow 2003, 2012
+
+#ifndef MEAS_IPP
+#define MEAS_IPP
+
+#ifdef _MSC_VER
+# pragma warning (push)
+#pragma warning (disable : 4189) // local variable is initialized but not referenced TODO!
+# pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+# pragma warning (disable : 4305) //C4305: 'initializing' : truncation from 'unsigned int' to 'short'.
+# pragma warning (disable : 4309) // C4309: 'initializing' : truncation of constant value.
+#endif
+
+#include <boost/date_time/gregorian/gregorian.hpp> //include all types plus i/o
+#include <boost/date_time/posix_time/posix_time.hpp> //include all types plus i/o
+
+//using namespace boost::gregorian;
+//using namespace boost::posix_time;
+
+#include <iostream>
+#include <cmath> // for fabs
+#include <functional> // for binary_function min
+
+#include <boost/quan/unc.hpp> // Declarations of class unc.
+#include <boost/quan/meas.hpp> // Declarations of class Meas, which calls this file.
+
+class Meas; // Measured uncertain value AND its id and order and/or time-date stamp.
+
+//using std::cout;
+//using std::cerr;
+//using std::endl;
+//using std::istream;
+//using std::ostream;
+//using std::min;
+//using std::binary_function; // <functional>
+
+// Global control of format output by class Meas.
+
+//const char timeFormatString[] = "%H:%M:%S"; // 12:20:55 time HH:MM:SS == "%X"
+ // "%H:%M"; // time as 12:26 HH:MM only, no seconds.
+ // "%X"; // 12:20:55 time HH:MM:SS
+ // "%d %b %y %H:%M:%S"; // 20 Apr 01 12:16:17
+ // "%d %b %y %H:%M"; // 20 Apr 01 12:16 // no seconds.
+ // "%a %b %d %m %Y %H:%M:%S %p"; // Fri Apr 20 04 2001 12:18:48 PM
+ // "%x"; // 04/20/01 US style MM/DD/YY.
+ // "%d %b %y"; // date as 20 Apr 01
+ // "%H:%M"; // time as 12:26 HH:MM only, no seconds.
+
+typedef double real_type; // or
+// typedef float real_type;
+
+// class Meas definitions
+// Measured value, id and its order and/or time-date.
+
+std::ostream& operator<< (std::ostream& os, const unc<false>& ud);
+// Need to instantiate for UReal<false> (might need for UReal<true> too).
+
+/*
+Meas::Meas()
+{ // Default constructor Usage: Meas z; (not Meas z()!) is exact zero.
+ value_ = 0.;
+ uncertainty_ = 0.F;
+ degFree_ = 0;
+ unctypes_ = UNC_KNOWN | UNC_EXPLICIT| DEG_FREE_EXACT | DEG_FREE_KNOWN;
+ time_ = ptime(not_a_date_time); // Time not known, and cannot be calculated from order.
+ order_ = -1; // Order not known, and cannot be calculated from time.
+ id_ = "";
+} // Meas::Meas()
+*/
+
+Meas::Meas(double d)
+{ // Constructor from double - needed by Meas(0.) lessAbs.
+ value_ = d;
+ uncertainty_ = 0.F;
+ degFree_ = 0;
+ unctypes_ = UNC_KNOWN | UNC_EXPLICIT| DEG_FREE_EXACT | DEG_FREE_KNOWN;
+ time_ = boost::gregorian::not_a_date_time; // Time not known, and cannot be calculated from order.
+ order_ = -1; // Order not known, and cannot be calculated from time.
+ id_ = "";
+#ifdef CD_TRACE
+ cerr << "Construct Meas from just double value " << value_ << "." << endl;
+#endif
+}
+/*
+Meas::Meas(uncun u)
+{ // Constructor from uncertain.
+ value_ = u.value_;
+ uncertainty_ = u.uncertainty_;
+ degFree_ = u.degFree_;
+ unctypes_ = u.unctypes_;
+ time_ = not_a_date_time; // Time not known, and cannot be calculated from order.
+ order_ = -1; // Order not known, and cannot be calculated from time.
+ id_ = "";
+#ifdef CD_TRACE
+ {
+ cerr << "Construct Meas from uncertain uncun " << value_ << "." << endl;
+ }
+#endif
+}
+
+Meas::Meas(uncun u, string id, ptime ti)
+: id_(id), time_(ti)
+{ // Constructor value, id & time (but NOT order) with default values.
+ order_ = -1; // order not known.
+ // (but may be calculated from time if in a sequence).
+ value_ = u.value_;
+ degFree_ =u.degFree_;
+ unctypes_ =u.unctypes_;
+ uncertainty_ = u.uncertainty_;
+#ifdef CD_TRACE
+ {
+ cerr << "Construct Meas using known time " << time_ << "." << endl;
+ }
+#endif
+}
+*/
+
+Meas::Meas(uncun u, string id, boost::posix_time::ptime ti /* = (boost::gregorian_time::not_a_date_time)*/, int order)
+: id_(id), time_(ti), order_(order)
+{ // Constructor value, id & order (but NOT time) with default values.
+ time_ = ti; // time not known, & cannot be calculated from order.
+ value_ = u.value_;
+ degFree_ =u.degFree_;
+ unctypes_ =u.unctypes_;
+ uncertainty_ = u.uncertainty_;
+#ifdef CD_TRACE
+ cerr << "Construct Meas using time AND known order " << time_ << ", " << order_ << "." << endl;
+#endif
+}
+
+/*
+Meas::Meas(uncun u, string id, int o)
+: id_(id), order_(o)
+{ // Constructor value, id & order (but NOT time) with default values.
+ time_ = boost::posix_time::not_a_date_time; // time not known, & cannot be calculated from order.
+ value_ = u.value_;
+ degFree_ =u.degFree_;
+ unctypes_ =u.unctypes_;
+ uncertainty_ = u.uncertainty_;
+ if(cdtrace)
+ {
+ cerr << "Construct Meas using known order " << time_ << "." << endl;
+ }
+}
+*/
+
+Meas::Meas(const Meas& rhs)
+{ // Copy constructor.
+ value_ = rhs.value_;
+ uncertainty_ = rhs.uncertainty_;
+ degFree_ = rhs.degFree_;
+ unctypes_ = rhs.unctypes_;
+ id_ = rhs.id_;
+ order_ = rhs.order_;
+ time_ = rhs.time_;
+ id_ = rhs.id_;
+}
+
+Meas::~Meas()
+{ // Default destructor used.
+}
+
+// Operators.
+
+// Meas& operator= (Meas&); // Assignment operator.
+Meas& Meas::operator= (const Meas& rhs) // Assignment operator.
+{ // Deep copy.
+ if (this == &rhs) return *this; // Assign to self, so do nothing.
+ value_ = rhs.value_;
+ uncertainty_ = rhs.uncertainty_;
+ degFree_ = rhs.degFree_;
+ unctypes_ = rhs.unctypes_;
+ order_ = rhs.order_;
+ time_ = rhs.time_;
+ id_ = rhs.id_;
+ return *this;
+}
+
+// Meas& abs (Meas&); // abs Assignment operator.
+Meas& Meas::abs(const Meas& rhs) // abs Assignment operator.
+{
+ value_ = fabs(rhs.value_);
+ uncertainty_ = rhs.uncertainty_;
+ degFree_ = rhs.degFree_;
+ unctypes_ = rhs.unctypes_;
+ order_ = rhs.order_;
+ time_ = rhs.time_;
+ id_ = rhs.id_;
+ return *this;
+}
+
+// Meas& abs (Meas&); // abs operator.
+Meas& Meas::abs(Meas& rhs) // abs Assignment operator.
+{
+ double d = rhs.value_;
+ //rhs.value_ = abs(d); // Not OK for reasons unclear - trying to use std::abs?
+ rhs.value_ = fabs(rhs.value_); // OK
+ return rhs;
+}
+
+bool Meas::operator== (const Meas& p) const
+{ // Exact Meas value Equality Comparison.
+ return (p.value_ == value_);
+ // What about checking if time the same too?
+} // Meas::operator==
+
+bool Meas::operator!= (const Meas& p) const
+{ // Comparison.
+ return (p.value_ != value_); // meas value differ (order && (p.order_ != order_).
+} // Meas::operator!=
+
+bool Meas::operator< (const Meas& rhs) const
+{// less uses operator< the most probable central value.
+ // member function so *this.value_ < *this.rhs.value_;
+ return (value_ < rhs.value_); // Comparison criterion.
+ // Only uses the measured value, not order.
+} // Meas::operator<
+
+bool Meas::operator> (const Meas& rhs) const
+{// greater uses operator> using the most probable value.
+ // member function so *this.value_ < rhs.value_;
+ return (value_ > rhs.value_);
+ // Comparison only uses the measured value (not order, nor time).
+} // Meas::operator>
+
+/*
+// What is meaning of adding measurements?
+// Has no meaning - can only add the values and uncertainty to get a new uncertain.
+// And time and order number can't be added, so
+// doubtful if operator+ and operator- are wise for Meas.
+bool Meas::operator- (const Meas& rhs) const
+{// Binary minus value using the most probable values.
+ // member function so *this.value_ < rhs.value_;
+ return value_ - rhs.value_; <<< wrong here <<<<<<<<<<<<
+ // Only uses the measured value (not order, nor time).
+} // Meas::operator>
+
+
+*/
+
+// Member predicate functions.
+
+// less uses template binary_function and operator<
+ /*
+ // TEMPLATE STRUCT less in functional
+template<class _Ty>
+ struct less
+ : public binary_function<_Ty, _Ty, bool>
+ { // functor for operator<
+ bool operator()(const _Ty& _Left, const _Ty& _Right) const
+ { // apply operator< to operands
+ return (_Left < _Right);
+ }
+ };
+ // So this function is the same as less<Meas> and so not needed.
+ bool Meas::lessM(const Meas& l, const Meas& r) // == less
+ { // Only uses the central measured value (not order, nor time).
+ return l.value_ < r.value_; // Comparison criterion.
+ }
+ // similarly nor is greater needed.
+ */
+
+bool Meas::lessAbsM(const Meas& l, const Meas& r)
+{ // Only uses the absolute central measured value, not order.
+ return ((l.value_ < 0.) ? -l.value_ : l.value_ ) < ((r.value_ < 0.) ? -r.value_ : r.value_);
+ // return std::abs(l.value_) < std::abs(r.value_); // Comparison criterion.
+ // but avoid abs because less efficient.
+} // bool Meas::lessAbsM(const Meas& l, const Meas& r)
+
+bool Meas::precedes(const Meas& l, const Meas& r)
+{ // Comparison criterion is order of measurement.
+ return l.order_ < r.order_;
+}
+
+/* Do we need this?
+bool Meas::succeeds(const Meas& l, const Meas& r)
+{ // Comparison criterion is order of measurement.
+ return l.order_ > r.order_;
+}
+*/
+
+// Call this "before"?
+bool Meas::earlier(const Meas& l, const Meas& r)
+{ // Comparison criterion is time of measurement.
+ // (Opposite, like greater, might be called 'later' - if needed).
+ if (l.time_ == boost::posix_time::not_a_date_time) return true; // not_a_date_time < any other time.
+ if (r.time_ == boost::posix_time::not_a_date_time) return false; // l.time_ IS a time, so r.time_ NOT <
+ return l.time_ < r.time_;
+} // bool Meas::earlier(const Meas& l, const Meas& r);
+
+bool Meas::less(const Meas& l, const Meas& r)
+{ // less using only value comparison.
+ // Note if lhi == rlo same then difference is 1.49012e-9 = numeric_limits<float>::epsilon
+ // (See also Meas::lessU and Meas::lessU2 which handle one and two standard deviations).
+
+ return l.value_ < r.value_;
+} // bool Meas::lessU(const Meas& l, const Meas& r)
+
+bool Meas::lessU(const Meas& l, const Meas& r)
+{ // less using comparison criterion including ONE standard deviation.
+ // Note if lhi == rlo then difference is 1.49012e-9 = numeric_limits<float>::epsilon
+ // (See also Meas::lessU2 which compares using TWO standard deviations).
+ double lhi = (l.value_ + l.uncertainty_); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_); // Lower confidence limit of right.
+ // double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ // diff = lhi - rlo;
+ // double tol = hypot(l.uncertainty_, r.uncertainty_); // Middle of two uncertainties.
+ bool isLess = lhi < (rlo + hypot(l.uncertainty_, r.uncertainty_)); // == less
+ if (true)
+ { // Output diagnostic info.
+ std::cerr << "<U #" << l.order_ << space << l.value_ << "="
+ << lhi // (l.value_ + l.uncertainty_)
+ << space << ((isLess) ? " < " : " !< ")
+ // << (r.value_ - r.uncertainty_) == rlo
+ << space << rlo << space << rlo + hypot(l.uncertainty_, r.uncertainty_) // tol
+ << " #" << r.order_ << "=" << r.value_
+ // << space << tol
+ // << space << diff
+ // For example: <U #1 1.1 1.2 !< 1.05 1.19142 #2 1.15
+ << std::endl;
+ }
+ return isLess;
+} // bool Meas::lessU(const Meas& l, const Meas& r)
+
+bool Meas::less2U(const Meas& l, const Meas& r)
+{ // less Comparison criterion including TWO standard deviations.
+ double lhi = (l.value_ + l.uncertainty_); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_); // Upper confidence limit of right.
+ double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ double tol = hypot(l.uncertainty_, r.uncertainty_);
+ // Might chose smallest, or largest uncertainty, or this compromise.
+ // Reverses the order when small uncertainty compared to large uncertainty and large chosen for tol.
+ bool isLess = lhi < (rlo + 0.0 * hypot(l.uncertainty_, r.uncertainty_)); // == less
+ if (true)
+ {
+ std::cerr << "<2U #" << l.order_ << "=" << l.value_ << space
+ << (l.value_ + l.uncertainty_)
+ << space << ((isLess) ? " < " : " !< ")
+ << (r.value_ - r.uncertainty_)
+ << space << rlo + 2.0 * tol
+ << " #" << r.order_ << "=" << r.value_
+// << space << diff
+ << std::endl;
+ }
+ return isLess;
+} // bool Meas::lessU2(const Meas& l, const Meas& r)
+
+bool Meas::greaterU(const Meas& l, const Meas& r)
+{ // l > r
+ // Uses Uncertain measured value, not order.
+ double lhi = (l.value_ + l.uncertainty_); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_); // Lower confidence limit of right.
+ double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ double tol = hypot(l.uncertainty_, r.uncertainty_);
+ // Might chose smallest, or largest uncertainty, or this compromise.
+ // Reverses the order when small uncertainty compared to large uncertainty and large chosen for tol.
+ bool isLess = lhi < (rlo + 0. * hypot(l.uncertainty_, r.uncertainty_)); // == less
+ return isLess;
+} // bool Meas::greater(const Meas& l, const Meas& r)
+
+bool Meas::equal_toUnc(const Meas& l, const Meas& r)
+{ // l ~== r equal within uncertainty.
+ // Uses Uncertain measured value, not order.
+ double lhi = (l.value_ + l.uncertainty_); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_); // Lower confidence limit of right.
+ double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ double tol = hypot(l.uncertainty_, r.uncertainty_);
+ // Might chose smallest, or largest uncertainty, or this compromise.
+ // Reverses the order when small uncertainty compared to large uncertainty and large chosen for tol.
+ bool isLess = lhi < (rlo + 0. * hypot(l.uncertainty_, r.uncertainty_)); // == less
+ return isLess;
+} // bool Meas::greater(const Meas& l, const Meas& r)
+
+// Global Output Meas::operator<<
+std::ostream& operator<< (std::ostream& os, const Meas& p) // Definition.
+{
+ // Uses:
+// std::ostream& operator<< (std::ostream& os, boost::posix_time::ptime);
+// std::ostream& operator<< (std::ostream& os, const unc<false>&);
+
+ // std::cout << p; is transformed to operator<< (std::cout, c); which does this:
+
+ //os << p.value_ << " "
+ //<< "+/-" << p.uncertainty_
+ //<< " (" << p.degFree_ << ")"
+ ////<< showuncflags // to display.
+ //<< " {" << std::hex << p.unctypes_ << std::dec << "}";
+ ////<< " {"
+ ////<< showUncTypes(p.unctypes_)
+ ////<< "}";
+
+ uncun u(p.value_, p.uncertainty_, p.degFree_, p.unctypes_);
+ os << u;
+
+ if(p.id_.size() != 0)
+ {// string identifier (if any).
+ os << " " << p.id_;
+ }
+ if (p.order_ >= 0)
+ { // means order is defined.
+ os << " #" << p.order_; // For example # 17
+ }
+ else
+ { // order undefined.
+ // So no output?
+ }
+ if (p.time_ != boost::posix_time::not_a_date_time)
+ {
+ os << ", " << p.time_; // Output t
+ }
+ // else don't output anything.
+ return os; // Allow chaining concatenation of << ... << .
+} // operator<<
+
+istream& operator>> (istream& is, Meas& p)
+{
+ uncun u;
+ is >> u;
+ p.value_ = u.value_;
+ p.uncertainty_ = u.uncertainty_;
+ p.degFree_ = u.degFree_;
+ p.unctypes_ = u.unctypes_;
+ is >> p.order_;
+ is >> p.id_;
+ is >> p.time_;
+
+ // 2 3 (could make smarter and/or require [2,3]).
+ return is; // Allow chaining concatention of >> ... >>.
+} // operator<<
+
+// Defined in unc.hpp, for example:
+
+//template <class T>
+//const double value_of(T&);
+
+template<>
+double value_of(Meas v) //! \return Meas.value() as a double.
+{ //! \return Meas.value() as a double.
+ return v.value();
+}
+
+template<>
+double unc_of(Meas u) //! \return Meas.std_dev() as a double.
+{
+ return u.std_dev();
+}
+
+//! Get values of a pair of values.
+template <> //! \tparam T1 and T2 Built-in floating-point types Meas and unc.
+std::pair<double, double> values_of(std::pair<Meas, uncun> vp)
+{
+ return std::make_pair<double, double>(value_of(vp.first), value_of(vp.second));
+}
+
+template <> //! \tparam T1 and T2 Built-in floating-point types Meas and unc.
+std::pair<double, double> values_of(std::pair<Meas const, uncun> vp)
+{
+ return std::make_pair<double, double>(value_of(vp.first), value_of(vp.second));
+}
+
+//! Get uncertainties (standard deviation) of a pair of values.
+template <> //! \tparam T Built-in floating-point type or unc.
+std::pair<double, double> uncs_of(std::pair<Meas, uncun> vp)
+{
+ return std::make_pair<double, double>(unc_of(vp.first), unc_of(vp.second));
+}
+
+template <> //! \tparam T Built-in floating-point type or unc.
+std::pair<double, double> uncs_of(std::pair<Meas const, uncun> vp)
+{
+ return std::make_pair<double, double>(unc_of(vp.first), unc_of(vp.second));
+}
+
+
+#if defined (BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif // MEAS_IPP

Added: sandbox/SOC/2007/quan/boost/quan/impl/unc.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/impl/unc.ipp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,880 @@
+/*!
+ \file
+ \brief Uncertain class definitions.
+ \details Class for simple Propagation of Uncertainties
+ according to a pure Gaussian model.
+ Uncertain subroutines, manipulators & applicators.
+ but not <iomanip> because defined here (as a copy of code in Std iomanip).
+*/
+
+// Copyright Paul A. Bristow 1998, 2012.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// unc.ipp
+
+//#ifndef UNC_IPP
+//#define UNC_IPP
+
+#include <boost/quan/unc.hpp> // Declarations of uncertain items.
+
+#include <iostream>
+//using std::ostream;
+
+//! 'Unique' value used to check xalloc initialised iwords are OK, and are not corrupted.
+const long indexID = 0x48dbaf8; //! Random id value.
+
+/*!
+ \brief Set 16 default values for uncertain output flags.
+ Might be best to make setUncDefaults also set ios_base defaults
+ with void setiosDefaults(ostream&);\n
+ Usage: \code setUncDefaults(cout); \endcode
+ \warning \c setUncDefaults() MUST be called before using a stream.
+ \details
+ Default iword(*) values are all zero - these are not usable.
+ Function \c setUncDefaults() sets some defaults
+ Can set individual value, for example, for 3 sig Digits, os.iword(sigDigitsIndex) = 3;
+ \note Index values must have been initialised by xalloc calls.
+*/
+void setUncDefaults(std::ios_base& os)
+{
+ os.iword(zeroIndex) = indexID; // Mark stream starting to set to defaults:
+
+ os.iword(uncFlagsIndex) = 0; // long& uncFlags == iword(1)
+ // uncFlags defaults mean flex, not set_scaled, not auto_scaled, not +/-,
+ // no symbol, no prefix, no noisy, not setSigDigits.
+ os.iword(oldUncFlagsIndex) = 0; // Old - not set yet. long& oldUncFlagsIndex == iword(2)
+ os.iword(sigDigitsIndex) = 3; // Default 3 significant digits for value.
+ os.iword(oldSigDigitsIndex) = 3; // Old @b set 3 significant digits for value.
+ os.iword(setSigDigitsIndex) = 3; // Default @b set 3 significant digits for value.
+ os.iword(uncSigDigitsIndex) = 2; // Default @b set 3 significant digits for value.
+ os.iword(setUncSigDigitsIndex) = 2; // Default 2 significant digits, as ISO standard.
+ os.iword(oldUncSigDigitsIndex) = -1; // No previous value for unc stdDev.
+ os.iword(scaleIndex) = 0; // Zero scale means was not scaled.
+ os.iword(oldScaleIndex) = -1; // No previous scale.
+ os.iword(setScaleIndex) = 0; // Assigned by uncSetScale(9).
+ os.iword(uncWidthIndex) = 10; // Default width 10 to allow +1.23E+12 & 1 fill_char.
+ os.iword(oldUncWidthIndex) = -1;
+ os.iword(oldUncSetWidthIndex) = -1; // Not used?
+ os.iword(usedIndex) = 0; // No chars output = used.
+ os.iword(oldUncUsedIndex) = -1; // No previous value.
+ os.iword(widthIndex) = -1; // ios setwidth
+ os.iword(oldWidthIndex) = -1; // previous ios setwidth
+ os.iword(roundingLossIndex) = 50; // 0.01 * 1000; // == 0.01
+ os.iword(confidenceIndex) = 50000; // == 0.05 * 1e6
+
+ os.iword(topIndex) = indexID; // last .iword(16) == iword(0)
+ // marking that all have been set to defaults.
+ if (os.iword(zeroIndex) != indexID)
+ { // Initialization of iwords failed!
+ std::cerr << "os.iword(0) = " << std::hex << os.iword(0)
+ << " not expected ID " << indexID << '!'
+ << "\nMissing call of setUncDefaults(ostream)?" << std::endl;
+ // throw; some exception TODO
+ }
+} // void setUncDefaults(std::ios_base& stream)
+
+/*! Output ALL the os.word() values to the ostream log.
+ \param os Current stream to be displayed in log.
+ \param logstream for log.
+*/
+void outUncValues(std::ostream& os, std::ostream& log)
+{ // Output ALL the os.word() values to the ostream log.
+ log //<< hex << "zero " << os.iword(zeroIndex) << dec // = indexID; // Mark if has been set to defaults.
+ << " " "UncValues: "
+ << "uncFlags " << std::hex << os.iword(uncFlagsIndex) << std::dec //= 0; // iword(1)
+ << ", setSigDigits " << os.iword(setSigDigitsIndex) // = 3; // Default set 3 sig digits.
+ << ", uncWidth " << os.iword(uncWidthIndex) // = 10; // Default width 10 to allow +1.234E12
+ << ", uncSetWidth " << os.iword(oldUncSetWidthIndex) // = 0; // Not used
+ << ", uncScale " << os.iword(scaleIndex) // = 0; // Zero scaling means was not scaled.
+ << ", uncSetScale " << os.iword(setScaleIndex) // = 0; // Zero scaling means not scaled.
+ << ", uncUsed " << os.iword(usedIndex) // = 0; // None used.
+ // Values saved by previous calls of uncprint.
+ << ", uncOldFlags " << os.iword(oldUncFlagsIndex) // = 0; // 0xFFFFFFFF to mean not valid?
+ << ", uncOldUncWidth " << os.iword(oldUncWidthIndex) // = 0;
+ << ", uncOldScale " << os.iword(oldScaleIndex) // = 0;
+ << ", uncSigDigits " << os.iword(setUncSigDigitsIndex) // = 2; // Default 2 sig digits.
+ << ", uncoldSigDigits " << os.iword(oldUncSigDigitsIndex) // = 0; // No previous value.
+ << ", oldUncUsed " << os.iword(oldUncUsedIndex) // = 0; // No previous value.
+ << ", oldStdDevSigDigits " << os.iword(oldUncSigDigitsIndex) // = 0; // No previous value for unc stdDev.
+ << ", setUncSigDigits " << os.iword(setUncSigDigitsIndex)
+ << ", roundingLossIndex " << os.iword(roundingLossIndex) / 1.e3
+ << ", confidenceIndex " << os.iword(confidenceIndex) / 1.e6
+
+ // << ", top " << hex << os.iword(topIndex) << dec
+ << std::endl;// = indexID; // last .iword(16) as check.
+} // void outUncValues()
+
+//! Description as a word of each bit in unc type, using enum unc_types.
+const char* uncTypeWords[16] =
+{
+ "zero", //!< 0 VALUE_ZERO value is zero.
+ "integer", //!< 1 VALUE_INTEGER value is an integer.
+ "rational", //!< 2 VALUE_RATIONAL value is rational.
+ "-only", //!< 3 VALUE_NEGATIVE_ONLY Value can ONLY be < 0.. ? or <=0?
+ "+only", //!< 4 VALUE_POSITIVE_ONLY Value can ONLY be >=0.
+ "uncKnown", //!< 5 UNC_KNOWN Uncertainty known
+ "noPlus", //!< 6 UNC_NOPLUS Uncertainty can only be < value, + = zero.
+ "noMinus", //!< 7 UNC_NOMINUS certainty can only be > value - = zero.
+ "quantize10", //!< 8 UNC_QUAN_DECIMAL Quantised by least significant decimal digit.
+ "quantize2", //!< 9 UNC_QUAN_BINARY Quantised by least significant binary digit.
+ "explicit", //!< 10 UNC_EXPLICIT not inferred from sig digits.
+ "uniform", //!< 11 UNC_UNIFORM uniform (or rectangular) probability distribution.
+ "triangular", //!< 12 UNC_TRIANGULAR Triangular probability distribution.
+ //! If neither bits set, then distribution type is normal (or gaussian).
+ //! If BOTH bits are, the distribution is undefined (as yet).
+ "df_exact", //!< 13 DEG_FREE_EXACT Exactly known number of observations.
+ "df_known", //!< 14 DEG_FREE_KNOWN Degrees of freedom defined.
+ "spare" //!< 15 SPARE
+};
+
+/*! Output word description for each unc_type bit.\n
+ Usage: outUncTypes(unc.getUncTypes(), cerr); // logs to cerr.
+ \param uncTypes uncertain types as a short int.
+ \param os ostream for output, default = cerr
+*/
+void outUncTypes(unsigned short int uncTypes, std::ostream& os = std::cerr)
+{// Usage: outUncTypes(unc.getUncTypes(), cerr); // logs to cerr.
+ const int count = 16; // because using 16-bit unsigned short int.
+ os << "uncTypes (" << std::showbase << std::hex << uncTypes << std::dec << ")" ;
+ for(int i = 0, j = 1; i < count; ++i)
+ {
+ if ((uncTypes & j) != 0)
+ {
+ os << ' ' << uncTypeWords[i] ;
+ }
+ j <<= 1;
+ } // for
+ os << ".";
+} // outUncTypes
+
+/*!
+ Usage: `out << showUncTypes(uncType)`
+ \param t Uncertain type flags.
+*/
+showUncTypes::showUncTypes(unsigned short int t) : types(t)
+{ // Constructor.
+}
+
+/*!
+ \nUsage: `out << showUncTypes(uncType)`
+ \param ut Uncertain type flags.
+ \param std::ostream for output of types as words.
+*/
+std::ostream& operator<< (std::ostream& os, const showUncTypes& ut) // Define.
+{
+ const int count = 16; // because using 16-bit unsigned short int.
+ unsigned short int uncTypes = ut.types;
+ os << "uncTypes (" << std::showbase << std::hex << uncTypes << std::dec << ")";
+ for (int i = 0, j = 1; i < count; ++i)
+ {
+ if ((uncTypes & j) != 0)
+ {
+ os << ' ' << uncTypeWords[i];
+ }
+ j <<= 1;
+ } // for
+ os << ".";
+ return os;
+} // ostream& operator<< (ostream& os, const showUncTypes& ut)
+
+/*! Show all the std io stream flags settings as words.\n
+ Usage: \code outIosFlags(cout.flags(), cerr); // logs cout's flag to cerr. \endcode
+ \param flags Iostream flags.
+ \param os Ostream for output.
+ */
+void outIosFlags(long flags, std::ostream& os = std::cerr)
+{ // Show all the std io stream flags settings as words.
+ os << "iosflags (" << flags << ")" << std::dec;
+ if (flags & std::ios_base::boolalpha) // Show bool as word strings "true" or "false".
+ os << " boolalpha";
+ if (flags & std::ios_base::skipws) // Skip white space on input.
+ os << " skipwhite";
+ if (flags & std::ios_base::left) // Left-align values; pad on the right with the fill character.
+ os << " left";
+ if (flags & std::ios_base::right) // Right-align values; pad on the left with the fill character (default alignment).
+ os << " right";
+ if (flags & std::ios_base::internal) // Add fill characters after any leading sign or base indication, but before the value.
+ os << " internal";
+ if (flags & std::ios_base::dec) // Format numeric values as base 10 (decimal) (default radix).
+ os << " dec";
+ if (flags & std::ios_base::oct) // Format numeric values as base 8 (octal).
+ os << " oct";
+ if (flags & std::ios_base::hex) // Format numeric values as base 16 (hexadecimal).
+ os << " hex";
+ if (flags & std::ios_base::showbase) // Display numeric constants in a format that can be read by the C++ compiler.
+ os << " showbase";
+ if (flags & std::ios_base::showpoint) // Show decimal point and trailing zeros for floating-point values.
+ os << " showpoint";
+ if (flags & std::ios_base::showpos) // Display plus sign in non-negative field.
+ os << " showpos";
+ if (flags & std::ios_base::uppercase) // Display uppercase A through F for hexadecimal values and E for scientific values.
+ os << " upper";
+ if (flags & std::ios_base::showpos) // Show plus signs (+) for positive values.
+ os << " show +";
+ if (flags & std::ios_base::scientific) // Display floating-point numbers in scientific format, for example: 1.23457e+001.
+ os << " scientific";
+ if (flags & std::ios_base::fixed) // Display floating-point numbers in fixed format, for example: 12.3456.
+ os << " fixed";
+ if ((flags & std::ios_base::scientific) && (flags & std::ios_base::fixed)) // Display floating-point numbers in hex format.
+ os << " hexFloat";
+ // TR1 adds both fixed and scientific as hexfloat.
+ // This is 15 - fmtflag appears to be limited by Dinkumware/MS fmtflags = 0xffff and most significant bit 15 is also used internally :-(
+ os << ".";
+} // out ios_base::flags(long flags, ostream&)
+
+
+/*! Show the set uncertain class io stream flags settings as words.
+ \param uncFlags Output flags to be displayed as words.
+ \param os Ostream for output.
+ Usage: \code outUncFlags(cout.flags(), cerr); // logs cout's flag to cerr. long& uncFlags = os.iword(uncFlagsIndex); \endcode
+*/
+void outUncFlags(long uncFlags, std::ostream& os = std::cerr)
+{
+ os << "uncFlags (" << std::showbase << std::hex << uncFlags << std::dec << ")";
+ os << ((uncFlags & firm) ? " firm" : "" );
+ if (uncFlags & setScaled) os << " set_scaled";
+ if (uncFlags & autoScaled) os << " auto_scaled";
+ if (uncFlags & plusMinus) os << " add_+/- ";
+ //if (uncFlags & addSISymbol) os << " add_SI_symbol";
+ //if (uncFlags & addSIPrefix) os << " add_SI_prefix";
+ if (uncFlags & limits) os << " addlimits";
+ if (uncFlags & noisyDigit) os << " addnoisy";
+ if (uncFlags & useSetSigDigits) os << " set_sigDigits";
+ if (uncFlags & useSetUncSigDigits) os << " set_uncsigDigits";
+ if (uncFlags & degfree) os << " adddegfree";
+
+ os << '.';
+} //
+
+// Parameterless manipulators to switch format to switch uncFlag bits,
+// flex - width just enough to display, suitable for non-tables,
+// or firm to fit into a set width, suitable for tables,
+// & similarly for scale and autoscale flag bits.
+// Note all lowercase to match convention of hex, oct ...
+
+std::ios_base& flexform(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~firm; // clear bit 0 = 0 to mean flex.
+ return iostr;
+}
+
+std::ios_base& firmform(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= firm; // set bit 0 = 1 to mean firm not flex.
+ return iostr;
+}
+
+std::ios_base& scale(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= setScaled; // set bit 1 = 1 to mean scaled.
+ return iostr;
+}
+
+std::ios_base& noscale(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~setScaled; // clear bit 1 = 0 to mean not scaled.
+ return iostr;
+}
+
+std::ios_base& autoscale(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= autoScaled; // set bit 2 = 1 to mean auto.
+ return iostr;
+}
+
+std::ios_base& noautoscale(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~autoScaled; // clear bit 2 = 0 to mean fixed.
+ return iostr;
+}
+
+std::ios_base& plusminus(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= plusMinus; // set bit 3 = 1 to mean plusminus.
+ return iostr;
+}
+
+std::ios_base& noplusminus(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~plusMinus; // clear bit 3 = 0 to mean not.
+ return iostr;
+}
+
+std::ios_base& addsisymbol(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= addSISymbol; // set bit 4 = 1 to add SI symbol.
+ return iostr;
+}
+
+std::ios_base& nosisymbol(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~addSISymbol; // clear bit 4 = 0 for no SI symbol.
+ return iostr;
+}
+
+std::ios_base& addsiprefix(std::ios_base& iostr)
+{ // Prefix (like kilo) used rather than Symbol (like k) if both SI prefix & symbol set.
+ iostr.iword(uncFlagsIndex) |= addSIPrefix; // set bit 5 = 1 to add SI prefix
+ return iostr;
+}
+
+std::ios_base& nosiprefix(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~addSIPrefix; // clear bit 5 = 0 for NO prefix.
+ return iostr;
+}
+
+std::ios_base& addnoisyDigit(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= noisyDigit; // set bit 6 = 1 to add noisy digit
+ return iostr;
+}
+
+std::ios_base& nonoisyDigit(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~noisyDigit; // clear bit 6 = 0 for NO noisy digit.
+ return iostr;
+}
+
+std::ios_base& autosigdigits(std::ios_base& iostr)
+{ // Use auto (calculated from uncertainty) not sig digits stored with `<< setSigDigits(6)` for value.
+ iostr.iword(uncFlagsIndex) &= ~useSetSigDigits; // clear bit 7 = 0 for auto sigdigits.
+ return iostr;
+}
+
+std::ios_base& setsigdigits(std::ios_base& iostr)
+{ // Use sig digits stored with `<< setSigDigits(6)` for value (not calculated from uncertainty).
+ iostr.iword(uncFlagsIndex) |= useSetSigDigits; // set bit 7 = 1 to use set sigdigits.
+ return iostr;
+}
+
+std::ios_base& autouncsigdigits(std::ios_base& iostr)
+{ // Calculate stdDev sig digits from uncertainty.
+ iostr.iword(uncFlagsIndex) &= ~useSetUncSigDigits; // clear bit 8 = 0 for auto unc sigdigits.
+ return iostr;
+}
+
+std::ios_base& setuncsigdigits(std::ios_base& iostr)
+{ //!< Use stdDev sigDigits stored with `<< useSetUncSigDigits(2) ...`
+ iostr.iword(uncFlagsIndex) |= useSetUncSigDigits; // set bit 8 = 1 to use set uncsigdigits.
+ return iostr;
+}
+
+std::ios_base& adddegfree(std::ios_base& iostr)
+{ // Add degrees of freedom as `(99)`.
+ iostr.iword(uncFlagsIndex) |= degfree; // set bit 9 = 1 to mean show degrees of freedom.
+ return (iostr);
+}
+
+std::ios_base& nodegfree(std::ios_base& iostr)
+{ // Do not add degrees of freedom
+ iostr.iword(uncFlagsIndex) &= ~degfree; // clear bit 9 = 0 to mean no degrees of freedom.
+ return (iostr);
+}
+
+std::ios_base& addreplicates(std::ios_base& iostr)
+{ // Show replicates (but only if if > 1).
+ iostr.iword(uncFlagsIndex) |= replicates; // set bit 0xA = 1 to mean replicates > 1.
+ return (iostr);
+}
+
+std::ios_base& noreplicates(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~replicates; // clear bit 0xA = 0 to mean no replicates.
+ // BUT still show degrees of freedom if required.
+ return (iostr);
+}
+
+std::ios_base& addlimits(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) |= limits; // Set bit 0xB = 0 to mean show limits.
+ return (iostr);
+}
+
+std::ios_base& nolimits(std::ios_base& iostr)
+{
+ iostr.iword(uncFlagsIndex) &= ~limits; // clear bit 0xB = 0 to mean no limits shown.
+ return (iostr);
+}
+
+// May need istream operator>> versions too?
+
+std::ios_base& showuncflags(std::ios_base& iostr)
+{
+ showUncFlags(static_cast<unsigned short>(iostr.iword(uncFlagsIndex)));
+ return iostr;
+}
+
+// Two overloaded uFlags functions, like ios_base setf.
+// (1st just returns current, other sets & returns old).
+long uFlags(std::ios_base& str)
+{
+ return str.iword(uncFlagsIndex); // Return streams current unc flags.
+ // Unlike ios_base member function fmtflags ios_base::flags(),
+ // these need to know their ios_base.
+}
+
+long uFlags(std::ios_base& str, long flags) // Assign new & return old.
+{
+ // lock(); may be required for multitasking (MT defined).
+ long oldflags = str.iword(uncFlagsIndex); // Save to return
+ str.iword(uncFlagsIndex) = flags; // Assign all bits.
+ // unlock();
+ return oldflags; // Previous flags.
+}
+
+long setuFlags(std::ios_base& str, long flags) // Set selected bits & return old.
+{
+ long oldflags = str.iword(uncFlagsIndex); // Save to return.
+ // lock();
+ str.iword(uncFlagsIndex) |= flags; // OR Set = 1 specific bits.
+ // unlock();
+ return oldflags; // Previous;
+}
+
+long resetuFlags(std::ios_base& str, long flags) // Reset bits & return old.
+{
+ long oldflags = str.iword(uncFlagsIndex); // to return
+ // lock();
+ str.iword(uncFlagsIndex) &= (~flags); // reset specified bits.
+ // unlock();
+ return oldflags; // Previous.
+}
+
+// Manipulator creation using class whose name is that of the manipulator
+// and << and >> operators.
+// Steve Teale p 182 suggests that this is longer code than using template
+// O, I or Smanip, but simpler to code and understand, and will run faster.
+
+// Manipulator uncFlags. Usage: out << showUncFlags(flags)
+
+// Class showUncFlags whose name is that of the manipulator & << >> operators,
+// defined in unc.hpp header, but constructor defined in unc.cpp.
+
+showUncFlags::showUncFlags(unsigned short int f) : flags(f)
+{ //! Constructor.
+ //! Usage: out << showUncFlags(static_cast<long>(is.iword(uncFlagsIndex))) ...
+}
+
+std::ostream& operator<< (std::ostream& os, const showUncFlags& uf) // Define.
+{ // Output uncFlags to this ostream.
+ unsigned short uncFlags = uf.flags;
+ os << "uncFlags ("<< std::hex << uncFlags << std::dec << ")";
+ os << ((uncFlags & firm) ? " firm" : "" );
+ if (uncFlags & setScaled) os << " setScaled";
+ if (uncFlags & autoScaled) os << " autoScaled";
+ if (uncFlags & plusMinus) os << " add_+/-";
+ if (uncFlags & addSISymbol) os << " add_SI_symbol";
+ if (uncFlags & addSIPrefix) os << " add_SI_prefix";
+ if (uncFlags & noisyDigit) os << " add_noisy";
+ if (uncFlags & useSetSigDigits) os << " use_set_sigfig";
+ if (uncFlags & useSetUncSigDigits) os << " use_set_uncsigfig";
+ os << ".";
+ return os;
+} // ostream& operator<< (ostream& os, const showUncFlags&)
+ //long& uncFlags = os.iword(uncFlagsIndex);
+
+
+// setAllUncflags(int flags);
+// Usage: out << setAllUncFlags(0x5a) ...
+setAllUncFlags::setAllUncFlags(int w) : flags(w) {}
+// Constructor initialisation assigns flags = w.
+
+std::ostream& operator<< (std::ostream& os, const setAllUncFlags& sf)
+{
+ os.iword(oldUncFlagsIndex) = os.iword(uncFlagsIndex); // Save all old flags.
+ os.iword(uncFlagsIndex) = sf.flags; // Set all flags.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setAllUncFlags& sf)
+{
+ is.iword(oldUncFlagsIndex) = is.iword(uncFlagsIndex); // Save all old flags.
+ is.iword(uncFlagsIndex) = sf.flags; // Set all flags.
+ return is;
+}
+
+// setUncflags(int flags, int mask);
+// Usage: out << setUncFlags(0x7) ...
+setUncFlags::setUncFlags(int w) : flags(w)
+{ // Constructor initialisation flags = w.
+
+}
+
+std::ostream& operator<< (std::ostream& os, const setUncFlags& sf)
+{
+ os.iword(oldUncFlagsIndex) = os.iword(uncFlagsIndex); // Save all oldflags.
+ os.iword(uncFlagsIndex) |= sf.flags; // Set (OR in) selected flags.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setUncFlags& sf)
+{
+ is.iword(oldUncFlagsIndex) = is.iword(uncFlagsIndex); // Save all old flags.
+ is.iword(uncFlagsIndex) |= sf.flags; // Set (OR in) selected flags.
+ return is;
+}
+
+// setMaskedUncflags(int flags, int mask);
+// Usage: out << setMaskedUncFlags(0xFFFF, 0x7) ...
+setMaskedUncFlags::setMaskedUncFlags(int w, int m) : flags(w), mask(m) {}
+// flags = w; mask = m; in effect.
+
+std::ostream& operator<< (std::ostream& os, const setMaskedUncFlags& sf)
+{
+ os.iword(oldUncFlagsIndex) = os.iword(uncFlagsIndex); // Save all flags.
+ os.iword(uncFlagsIndex) =
+ (sf.flags & sf.mask) | (sf.flags & ~sf.mask); // Set selected flags to mask.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setMaskedUncFlags& sf)
+{
+ is.iword(oldUncFlagsIndex) = is.iword(uncFlagsIndex); // Save all flags.
+ is.iword(uncFlagsIndex) =
+ (sf.flags & sf.mask) | (sf.flags & ~sf.mask); // Set selected flags to mask.
+ return is;
+}
+
+// resetUncflags(int flags);
+// Usage: out << setMaskedUncFlags(0xF) ...
+resetUncFlags::resetUncFlags(int w) : flags(w) {} // Constructor initialisation flags = w.
+
+std::ostream& operator<< (std::ostream& os, const resetUncFlags& sf)
+{
+ os.iword(oldUncFlagsIndex) = os.iword(uncFlagsIndex); // Save previous.
+ os.iword(uncFlagsIndex) &= ~sf.flags; // Clear specific bits = 0.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const resetUncFlags& sf)
+{
+ is.iword(oldUncFlagsIndex) = is.iword(uncFlagsIndex); // Save previous.
+ is.iword(uncFlagsIndex) &= ~sf.flags; // Clear specific bits = 0.
+ return is;
+}
+
+// setMaskedUncflags(int flags, int mask);
+// Usage: out << setMaskedUncFlags(0xFFFF, 0x7) ...
+resetMaskedUncFlags::resetMaskedUncFlags(int w, int m) : flags(w), mask(m) {}
+// Constructor initialisation flags = w.
+
+std::ostream& operator<< (std::ostream& os, const resetMaskedUncFlags& sf)
+{
+ os.iword(oldUncFlagsIndex) = os.iword(uncFlagsIndex); // Save all flags.
+ os.iword(uncFlagsIndex) =
+ (sf.flags & sf.mask) & ~(sf.flags & ~sf.mask); // Clear selected flags to mask.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const resetMaskedUncFlags& sf)
+{
+ is.iword(oldUncFlagsIndex) = is.iword(uncFlagsIndex); // Save all flags.
+ is.iword(uncFlagsIndex) =
+ (sf.flags & sf.mask) & ~(sf.flags & ~sf.mask); // Clear selected flags to mask.
+ return is;
+}
+
+// Usage: out << setUncWidth(12) ...
+setUncWidth::setUncWidth(int w) : uncWidth(w)
+ { // Constructor.
+ }
+
+std::ostream& operator<< (std::ostream& os, const setUncWidth& sw)
+{
+ os.iword(oldUncWidthIndex) = os.iword(uncWidthIndex); // Save old.
+ os.iword(uncWidthIndex) = sw.uncWidth; // Set new uncertain width.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setUncWidth& sw)
+{
+ is.iword(oldUncWidthIndex) = is.iword(uncWidthIndex); // Save old.
+ is.iword(uncWidthIndex) = sw.uncWidth;
+ return is;
+}
+
+// setScale(int scale);
+// Usage: out << setScale(6) ... // == 10**6
+// & << scale to use this set scale value, or << noscale to ignore.
+setScale::setScale(int scale) : scale(scale)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const setScale& sc)
+{ //
+ os.iword(oldScaleIndex) = os.iword(setScaleIndex); // Save old.
+ os.iword(setScaleIndex) = sc.scale;
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setScale& sc)
+{
+ is.iword(oldScaleIndex) = is.iword(setScaleIndex); // Save old.
+ is.iword(setScaleIndex) = sc.scale;
+ return is;
+}
+
+/*! setSigDigits(int sigDigits);
+\brief Set the number of significant digits that can be used.
+(If required by `<< sigfiged` then use set sigDigits value, or noSigfiged to @b NOT use sigDigits).
+// Usage: `out << setSigDigits(5) << setsigdigits ...`
+// & either `<< setsigdigits` to use set sigDigits value, or ` << nosetsigdigits` to not use the set sigDigits.
+*/
+setSigDigits::setSigDigits(int w) : sigDigits_(w)
+{ // Constructor sigDigits = w;
+}
+
+std::ostream& operator<< (std::ostream& os, const setSigDigits& sf)
+{
+ os.iword(oldSigDigitsIndex) = os.iword(setSigDigitsIndex); // Save previous.
+ os.iword(setSigDigitsIndex) = sf.sigDigits_; // Set new sigDigits for value.
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setSigDigits& sf)
+{
+ is.iword(oldSigDigitsIndex) = is.iword(setSigDigitsIndex); // Save previous.
+ is.iword(setSigDigitsIndex) = sf.sigDigits_; // Set new sigDigits.
+ return is;
+}
+
+//! setUncSigDigits(int sigDigits);
+//! Usage: `out << setUncSigDigits(3) ...`
+// has the effect `cout.iword[setUncSigDigitsIndex] = 3;`
+setUncSigDigits::setUncSigDigits(int w) // : uncSigDigits_(w)
+{
+ if (w == 0)
+ {
+ w = 2; // ISO default.
+ }
+ else if (w > 3)
+ {
+ w = 3; // Limit to biggest that makes sense.
+ }
+ // Passes negative values through to allow
+ // an auto mode for w < 0 that chooses from degrees of freedom,
+ // (can't read degfree from here).
+ // From table H page 457 in Oliver & Goldsmith, confidence interval
+ // of standard deviation is about +/- 20% at 10 degrees of freedom,
+ // and only < +/- 10% above 100 observations (needing 2 stdDev sig Digits).
+ uncSigDigits_ = w;
+} // Constructor sets uncSigDigits = w.
+
+std::ostream& operator<< (std::ostream& os, const setUncSigDigits& usf)
+{
+ os.iword(oldUncSigDigitsIndex) = os.iword(setUncSigDigitsIndex); // Save previous.
+ os.iword(setUncSigDigitsIndex) = usf.uncSigDigits_; // Set new uncSigDigits.
+ return os;
+}
+
+//! setroundingLoss(double eps);
+//! Usage: out << setroundingLoss(0.01) ... = cout.iword[roundingLoss] = 0.01;
+setRoundingLoss::setRoundingLoss(double eps)
+{ // Constructor sets roundingLoss = parameter eps (scaled by operator<<).
+
+ roundingloss_= eps;
+}
+std::ostream& operator<< (std::ostream& os, const setRoundingLoss& sl)
+{ //! \note Can't store `double` in a `long`, so scale up to an integer.
+ os.iword(roundingLossIndex) = static_cast<long>(sl.roundingloss_ * 1.e3);
+ return os;
+}
+
+//! setConfidence(double alpha);
+//! Usage: out << setConfidence(0.01) ... = cout.iword[confidence] = 0.01;
+setConfidence::setConfidence(double alpha)
+{ // Constructor sets confidence = parameter alpha (scaled by operator<<).
+ confidence_= alpha;
+}
+
+std::ostream& operator<< (std::ostream& os, const setConfidence& sl)
+{ //! \note Can't store `double` in a `long`, so scale up to an integer.
+ os.iword(confidenceIndex) = static_cast<long>(sl.confidence_ * 1.e6);
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, const setUncSigDigits& usf)
+{
+ is.iword(oldUncSigDigitsIndex) = is.iword(setUncSigDigitsIndex); // Save previous.
+ is.iword(setUncSigDigitsIndex) = usf.uncSigDigits_; // Set new uncSigDigits.
+ return is;
+}
+
+// These all fail to link when placed here???? So left in unc.hpp until understand why.
+
+//! Squared function, notationally convenient for a^2, but overflow possible?
+//template <typename Type>
+//inline Type sqr(const Type& a)
+//{
+// return a * a;
+//}
+
+//! Cubed function, notationally convenient for x^3, but overflow possible?
+//template <typename Type>
+//inline Type cube(const Type& a)
+//{
+// return a * a * a;
+//}
+
+////! Quaded function, notationally convenient for x^4, but overflow possible?
+////! Used by Welch-Satterthwaite formula.
+//template <typename Type>
+//inline Type pow4(const Type& a)
+//{
+// return a * a * a * a;
+//}
+/*! Hypot or Square root of the sum of the squares of two numbers,
+ which is equal to the length of the hypotenuse of a right
+ triangle if the two arguments are the lengths of the legs.
+ Used for uncertainty propagation.
+*/
+//template <typename Type>
+//inline Type sqrtSumSqrs (const Type& a, const Type& b)
+//{
+// return (Type)sqrt(a * a + b * b);
+//}
+//
+
+// Definitions for explicit instantiation for double uncun, mMeas.
+// Definitions must only be in .cpp if unc.hpp included more than once
+// or will get link error "already defined".
+
+//
+//!< \tparam T value type convertible to double.
+template<>
+double value_of(double v)
+{ //! \return value as a double.
+ return double(v);
+}
+
+template <class T> //!< \tparam T value type convertible to double.
+double value_of(T v)
+{ //! \return value as a double.
+ double result = static_cast<double>(v.value());
+ return result;
+}
+
+template<>
+double value_of(unc<true> v)
+{ //! \return unc.value() as a double.
+ return v.value();
+}
+
+template<>
+double value_of(unc<false> v)
+{ //! \return unc.value() as a double.
+ return v.value();
+}
+
+template <class T>
+double unc_of(T v)
+{ //! \return zero if no uncertainty information is available (for built-in double, float, or long double).
+ return v.std_dev();
+}
+
+template <>
+double unc_of(double)
+{ //! \return zero if no uncertainty information is available (for built-in double, float, or long double).
+ return 0.F;
+}
+
+template <>
+double unc_of(float)
+{ //! \return zero if no uncertainty information is available (for built-in double, float, or long double).
+ return 0.F;
+}
+
+template <>
+double unc_of(uncun u)
+{ //! \return zero if no uncertainty information is available (for built-in double, float, or long double).
+ return u.std_dev();
+}
+
+// Pairs of values.
+
+template <> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<double, double> vp)
+{ //!< \return values of a pair of double values.
+ return std::make_pair(value_of(vp.first), value_of(vp.second));
+}
+
+// Const vrsion
+template <> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<double const, double> vp)
+{ //!< \return values of a pair of double values.
+ return std::make_pair(value_of(vp.first), value_of(vp.second));
+}
+
+template <> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<uncun, uncun> vp)
+{ //!< \return values of a pair of double values.
+ return std::make_pair(value_of(vp.first), value_of(vp.second));
+}
+
+template <> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<uncun const, uncun> vp)
+{ //!< \return values of a pair of double values.
+ return std::make_pair(value_of(vp.first), value_of(vp.second));
+}
+
+//! Get uncertainties (standard deviation) of a pair of values.
+template <> //! \tparam T Built-in floating-point type or unc.
+std::pair<double, double> uncs_of(std::pair<double, double> vp)
+{
+ return std::make_pair<double, double>(unc_of(vp.first), unc_of(vp.second));
+}
+
+//! Get uncertainties (standard deviation) as a pair of double values.
+template <> //! \tparam T Built-in floating-point type or unc.
+std::pair<double, double> uncs_of(std::pair<uncun, uncun> vp)
+{
+ return std::make_pair<double, double>(unc_of(vp.first), unc_of(vp.second));
+ //! \return uncs_of uncertainties (standard deviation) as a pair of double values.
+}
+
+//! Get uncertainties (standard deviation) as a pair of const float values.
+template <class T> //! \tparam T Builtin-floating point type or unc.
+const std::pair<float, float> uncs_of(std::pair<const T, T> vp)
+{ //! \return uncertainty parts (if any) as a pair of floats.
+ // so can write
+ // std::pair<const float, float> minmax = values_of(*result.first); // min unc & max unc for example/
+ // whether T is built-in or unc.
+ return std::make_pair(vp.first.unc(), vp.second.unc());
+ //! \return uncs_of uncertainties (standard deviation) as a pair of @b float values.
+}
+
+//// Diagnostic printout version of constructors here just for testing.
+//
+//// Note both correlated and uncorrelated versions needed unless use a template.
+//// C2906: 'unc<is_correlated>::~unc(void)' : explicit specialization requires 'template <>'
+//template<> unc<true>::~unc() // Definition.
+//{
+//#ifdef UNC_CD_TRACE
+// {
+// cerr << "\n___ Destruct unc<true> members: "
+// << value_ << ", Unc " << float(uncertainty_)
+// << ", df " << dec << degFree_
+// << showUncTypes(unctypes_)
+// << endl;
+// }
+//#endif
+//} // Destructor
+//
+//template<> unc<false>::~unc() // Definition.
+//{
+//#ifdef UNC_CD_TRACE
+// {
+// cerr << "\n___ Destruct unc<false> members: "
+// << value_ << ", Unc " << float(uncertainty_)
+// << ", df " << dec << degFree_
+// << showUncTypes(unctypes_)
+// << endl;
+// }
+//#endif
+//} // Destructor
+//#endif // UNC_IPP

Added: sandbox/SOC/2007/quan/boost/quan/impl/unc_input.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/impl/unc_input.ipp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,421 @@
+/*!
+ \file
+ \brief Testing uncertain classes using Boost Test Tool.
+ \details Class for simple Propagation of Uncertainties
+ according to a pure Gaussian model.
+*/
+
+// Copyright Paul A. Bristow 1998, 2012.
+
+// unc_input.cpp
+
+#include <iosfwd>
+//#include <boost/quan/unc.hpp>
+
+void unc_input(
+ double& value, // mean, central or most probable value.
+ double& stdDev, // float& ??
+ unsigned short int& degreesOfFreedom, // 1 observation.
+ unsigned short int& types, // TODO settings bits.
+ std::istream& is = std::cin)
+{ // Inputs uncertainty as value, (implicitly exact, std deviation = 0).
+ // & optionally [[+]|[-] <standard deviation * 2. >],
+ // (1.0 implies 1. +|- 0.5 and sd of 0.5,
+ // 1.00 implies 1. +|- 0.05 and sd of 0.05)
+
+ // & optionally degrees of freedom [(<short int>)] like (99)
+ // Used by istream& operator>> (istream&, unc<is_correlated>&)
+ // Original simple version:
+ //char plus, slash, minus;
+ //s >> value >> plus >> slash >> minus >> stdDev;
+ //if ((plus != '+') || (slash != '/') || (minus != '-'))
+ //{
+ //cerr << "Unexpected characters encountered in reading "
+ //"value +/- stdDev !" << endl;
+ //is.setf(ios_base::failbit);
+ //}
+
+ using std::istream;
+ using std::ostream;
+ using std::ios_base;
+ using std::char_traits;
+ using std::cout;
+ using std::cerr;
+ using std::cin;
+ using std::endl;
+ using std::flush;
+ using std::ws;
+ using std::streamsize;
+ using std::boolalpha;
+ using std::dec;
+ using std::hex;
+ using std::showbase;
+ using std::fixed;
+ using std::scientific;
+ using std::right;
+ using std::showpos;
+ using std::noshowpos;
+ using std::noshowbase;
+ using std::noshowpoint;
+ using std::showpoint;
+
+ std::streamsize avail = is.rdbuf()->in_avail();
+ if (avail == 0)
+ {
+ std::cerr << "No input available!" << std::endl;
+ value = std::numeric_limits<double>::quiet_NaN();
+ stdDev = std::numeric_limits<float>::quiet_NaN();
+ degreesOfFreedom = 0;
+ types = 0U;
+ return; // todo
+ }
+
+ // 'Default' values for unc_input arguments.
+ value = 0.; // double mean, central or most probable value.
+ stdDev = 0.f; // Exact float std deviation, unless find otherwise.
+ degreesOfFreedom = 1U; // Default == 1 observation.
+ types = 0U;
+ //static_cast<unsigned short>(~(VALUE_ZERO | VALUE_INTEGER | VALUE_RATIONAL| VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY | UNC_KNOWN | UNC_NOPLUS
+ // | UNC_NOMINUS | UNC_QUAN_DECIMAL | UNC_QUAN_BINARY | UNC_EXPLICIT | UNC_UNIFORM | UNC_TRIANGULAR | DEG_FREE_EXACT | DEG_FREE_KNOWN));
+
+ // All these need to be 'global' to uncertainRead, so declared here.
+ // char_traits<char>::int_type c;
+ // no_unused_variable_warning(c);
+ int iv = 0; // Integer part of floating point number.
+ double fv = 0.; // Fractional part of floating point number.
+ int exponent = 0; // Exponent power of 10, default 10 ^ 0 = 1.
+// bool isPositive = true; // Value input is >= 0.
+ bool isNegativeValue = false; // Value input < 0.
+ bool isPlusMinus = false; // Normal case is +/- or +|-.
+ bool isPlus = false; // +0
+ bool isMinus = false; // -0
+ bool isExactValue = true; // Assume no digits follow.
+ bool isZeroValue = true; // Until find either integer or fractional part != 0
+ bool isIntegerValue = false;
+ bool isExponent = false;
+ // bool isValueZero = false;
+ // Rationale for doing own read rather than using standard is to be able to distinguish
+ // integer "0" or "123" implicitly exact from real "0." implicitly +/- 0.5.
+ // Read integer part as one integer, option decimal as another, and fractional part as another,
+ // then optional exponential part,
+ // before any +/- and degrees of freedom as (999).
+
+ is >> ws; // Skip any leading whitespace.
+ is >> iv; // & read integer part of value (perhaps ii part of floating point number ii.ffe+ddd).
+ // if (is.bad()) // Not useful to distinguish overflow etc.
+ // if (is.eof()) // Sets fail for overflow, so not useful.
+ if (!is)
+ { // No integer part of value.
+ cerr << "No numeric value input! " << showiostate << endl;
+ value = std::numeric_limits<double>::quiet_NaN();
+ stdDev = std::numeric_limits<float>::quiet_NaN();
+ types = static_cast<unsigned short>(~(VALUE_ZERO | VALUE_INTEGER | VALUE_RATIONAL| VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY | UNC_KNOWN | UNC_NOPLUS
+ | UNC_NOMINUS | UNC_QUAN_DECIMAL | UNC_QUAN_BINARY | UNC_EXPLICIT | UNC_UNIFORM | UNC_TRIANGULAR | DEG_FREE_EXACT | DEG_FREE_KNOWN));
+ // == 0U; // None of the above are true.
+ // is.fail() == true; is.good() == false; // already
+ return;
+ } // is.failed
+ isIntegerValue = true; // but may be negated if find a decimal point later.
+ types |= UNC_KNOWN;
+ types &= ~UNC_EXPLICIT; // Clear bit because implicit from
+ // number of significant decimal digits - unless + or - provided.
+
+ isNegativeValue = (iv < 0) ? true : false;
+ // Overflow possible here if > numeric_limits<long>::max() == 2147483647
+ // for example, 99999999999999.
+ if (is.fail())
+ { // Check for overflow & other problems.
+ std::cerr << "\t" "Uncertain value input failed! "<< showiostate << std::endl;
+ value = std::numeric_limits<double>::quiet_NaN();
+ stdDev = std::numeric_limits<float>::quiet_NaN();
+ types = static_cast<unsigned short>(~(VALUE_ZERO | VALUE_INTEGER | VALUE_RATIONAL| VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY | UNC_KNOWN | UNC_NOPLUS
+ | UNC_NOMINUS | UNC_QUAN_DECIMAL | UNC_QUAN_BINARY | UNC_EXPLICIT | UNC_UNIFORM | UNC_TRIANGULAR | DEG_FREE_EXACT | DEG_FREE_KNOWN));
+ // == 0U; // None of the above true.
+ return;
+ } // is.fail
+
+ if (is.peek() == '.') // locale.decimal_point[0] better.
+ { // A decimal fractional part may follow.
+ is.get(); // Get (and discard) decimal_point.
+ isIntegerValue = false; // Because . follows digit, so "9" is exact integer but "9." is not,
+ // Even if no digits follow.
+ isExactValue = false;
+ stdDev = 0.5; // Implicit +/- if "9.", implies sd = 0.5.
+ types |= UNC_QUAN_DECIMAL; // Quantised by least significant decimal digit.
+ types &= ~UNC_EXPLICIT; // Clear - explicit because implied by significant digits.
+ int count = 0; // Number of digits. TODO ?? is this info used?
+ if (isdigit(is.peek()))
+ { // There is a decimal fraction part.
+ double fracTen = 1.;
+ while (isdigit(is.peek()))
+ {
+ ++count;
+ stdDev *= 0.1f; // Implicitly 1. means +/- 0.5 == stdDev = 0.05, 0.005 ...
+ fracTen *= 0.1;
+ int digit = (is.get() -'0');
+ fv += digit * fracTen;
+ // Potential for underflow to zero here?
+ }
+ if (isNegativeValue) fv = -fv;
+ if (fv != 0)
+ {
+ isIntegerValue = false;
+ }
+ } // Is a fraction part.
+ } // Is a decimal_point.
+ else if (is.peek() == '/')
+ { // Is a fraction, for example 2/3, so flag as a rational.
+ is.get(); // Get (and discard) /.
+ int denom;
+ is >> denom;
+ if (denom != 0)
+ {
+ value = static_cast<double>(iv)/denom;
+ iv = 0;
+ fv = 0;
+ types |= VALUE_RATIONAL;
+ types &= ~VALUE_ZERO;
+ }
+ }
+ value += iv + fv; // Combine integer and fractional parts.
+
+ if ((is.peek() & 0x5F ) == 'E') // 'e' or 'E'
+ { // Exponential part.
+ is.get(); // and discard 'e' or 'E'.
+ is >> exponent;
+ isExponent = true;
+ } // Exponent
+
+ if (value == 0)
+ {
+ isZeroValue = false;
+ types |= VALUE_ZERO;
+ }
+
+ if (isIntegerValue)
+ {
+ value = iv;
+ types |= (UNC_KNOWN | VALUE_INTEGER | VALUE_RATIONAL );
+// types |= (UNC_KNOWN | VALUE_INTEGER | VALUE_RATIONAL | UNC_NOPLUS | UNC_NOMINUS);
+#ifdef UNC_TRACE
+ { // Implicitly exact +/- 0
+ std::cerr << " URead: Exact integer = " << value << std::endl;
+ }
+#endif
+ }
+ else
+ { // Real NOT integer.
+ types |= UNC_KNOWN; // Known.
+ types &= ~(VALUE_INTEGER | VALUE_RATIONAL | UNC_NOPLUS | UNC_NOMINUS );
+#ifdef UNC_TRACE
+ {
+ std::cerr << " URead: " << value << " implicit +/- " << stdDev << ". ";
+ }
+#endif
+ } // integer or not.
+
+ is >> ws; // Skip optional whitespace between "123.45" and "+/-".
+
+ // Check if explicit uncertainty +/- (or +|-, or +-) or + or - follows,
+ // & read uncertainty if it does.
+ double expUnc = 0.; // Explicit uncertainty.
+ // 0x0F1 is files code for the single char '+-' symbol,
+ if (!is.eof())
+ { // Uncertainty (standard deviation) and degrees of freedom may follow.
+ if ((is.peek() == '+') || (is.peek() == '-'))
+ { // Some uncertainty, for example: +0.123, -0.456 or "+/-2.34"
+ std::char_traits<char>::int_type c = is.get(); // '+' or '-' read and discard.
+ if(c == '+')
+ {
+ isPlus = true;
+ }
+ if(c == '-')
+ {
+ isMinus = true;
+ }
+ std::char_traits<char>::int_type p = is.peek();
+ // 0xdd is File code for | vertical bar.
+ // 0x0F1 is single char in files for '+-' symbol.
+ if (p == '/' || p == '|' || p == '\\' || p == 0xDD || p == 0x0F1)
+ { // Skip over any separator.
+ std::char_traits<char>::int_type c = is.get(); // '/' or '|' or '\' chars.
+ if (c == 0x0F1)
+ { // '+-' symbol, so must be both + and -.
+ isPlus = true;
+ isMinus = true;
+ }
+ // is >> ws; // Ignore any layout. Bad idea to allow "+/ -"
+ p = is.peek(); // Expect + or - after separator.
+ if (p == '+' || p == '-')
+ { // +/- and +|- both allowed (or -/+ or -|+).
+ // Assume +/+ uncertainty means just + and -/-, and uncertainty just -.
+ std::char_traits<char>::int_type c = is.get(); // expect 2nd '+' or '-' char.
+ if (c == '+')
+ {
+ isPlus = true;
+ // else "*/+"
+ is >> expUnc; // Input Explicit uncertainty.
+ if (!is.fail())
+ { // Read OK, set bits.
+ types |= (UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ else
+ { // Reading uncertainty (standard deviation) value was not OK, so clear.
+ types &= ~(UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ } // == '+'
+ else if (c == '-')
+ {// else "*/-"
+ isMinus = true;
+ is >> expUnc; // Input Explicit negative uncertainty (have already consumed the - sign).
+ if (!is.fail())
+ { // Read OK, set bits.
+ types |= (UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ else
+ { // NotOK, so clear.
+ types &= ~(UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ } // == '-'
+ }
+ else
+ { // Unexpected char (not + or -) after separator!
+ // TODO Need to signal fail!
+ }
+ }
+ else if (c == '+')
+ { // Positive uncertainty only, for example: "+0.123"
+ isPlus = true;
+ is >> expUnc; // Will consume the + sign.
+ if (!is.fail())
+ { // Read OK, set bits.
+ types |= (UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN | UNC_NOMINUS);
+ }
+ else
+ { // NotOK, so clear.
+ types &= ~(UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN | UNC_NOMINUS);
+ }
+ }
+ else if (c == '-')
+ { // // Negative uncertainty only, for example: "-0.123"
+ isMinus = true;
+ is >> expUnc;
+ // expUnc = -expUnc; // Have already consumed the '-' sign! But stddev is always positive.
+ if (!is.fail())
+ { // OK, so set uncertain type flags.
+ types |= (UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ else
+ { // NotOK so clear flags.
+ types &= ~(UNC_KNOWN | UNC_EXPLICIT | UNC_QUAN_DECIMAL | UNC_KNOWN );
+ }
+ } // == '-'
+ }
+
+ if (isPlus || isMinus)
+ { // Some plus and/or minus value has been input.
+ types |= (UNC_KNOWN | UNC_EXPLICIT);
+ if ((isPlus) && (isMinus))
+ {
+ isPlusMinus = true; // If both plus and minus uncertainty.
+ types &= ~(UNC_NOMINUS | UNC_NOPLUS); // Clear both exclusive,
+ stdDev = static_cast<float>(expUnc);
+ }
+ else
+ // if (!isPlusMinus) // Only + or -, but not both.
+ {
+ if (isPlus)
+ {
+ types |= UNC_NOMINUS;
+ }
+ else if (isMinus)
+ {
+ types |= UNC_NOPLUS;
+ }
+ stdDev = static_cast<float>(expUnc);
+ } // not both.
+ } // isPlus or isMinus
+ else
+ { // Implicit.
+ stdDev = static_cast<float>(stdDev); //
+ }
+
+#ifdef UNC_TRACE
+ {
+ std::cerr << " Explicit uncertainty ";
+ if (isPlusMinus)
+ {
+ std::cerr << " +/- ";
+ }
+ else
+ {
+ std::cerr << ((isPlus) ? "+ " : "");
+ std::cerr << ((isMinus) ? "- " : "");
+ }
+ std::cerr << expUnc << ", stdDev " << stdDev << endl;
+
+ } // trace
+#endif
+ // Degrees of freedom?
+ is >> ws; // Eat any whitespace before "(99)".
+ if (!is.eof())
+ { // Degrees of freedom as "(99)" may follow.
+ // (Default degreesOfFreedom = 0; == 1 observation.
+ if (is.peek() == '(')
+ { // 99) follows
+ std::char_traits<char>::int_type c = is.get(); // Discard '('
+ long df; // degreesOfFreedom is only unsigned short 16 bit integer, so might overflow,
+ is >> df; // but read into a temporary long int to do some checks.
+ if (is.fail())
+ { // long int not read OK.
+ degreesOfFreedom = (std::numeric_limits<unsigned short int>::max)(); // 0xFFFF; = Not known.
+ types &= ~(DEG_FREE_KNOWN | DEG_FREE_EXACT); // Clear these flags.
+ }
+ else
+ { // long degrees of freedom read OK, so check >=0, and not too big.
+ if (df < 0)
+ { // Can't have negative degrees of freedom!
+ degreesOfFreedom = (std::numeric_limits<unsigned short int>::max)(); // 0xFFFF; = Not known.
+ types &= ~(DEG_FREE_KNOWN | DEG_FREE_EXACT); // NOT defined.
+ }
+ else
+ { // df >= 0
+ degreesOfFreedom =
+ (df >= (std::numeric_limits<unsigned short int>::max)()) ?
+ (std::numeric_limits<unsigned short int>::max)() -1
+ // max df allowed.
+ : static_cast<unsigned short int>(df); // 1 observation == 1 degfree.
+ }
+ c = is.peek(); // Expect ')'
+ if (c == ')')
+ {
+ is.get(); // Discard ')'
+ types |= (DEG_FREE_KNOWN | DEG_FREE_EXACT); // deg_free IS known and integer so exact.
+ }
+ if (c != ')' || (is.fail()) )
+ { // (99 OK but missing bracket.
+ degreesOfFreedom = (std::numeric_limits<unsigned short int>::max)(); // 0xFFFF; = Not known.
+ types &= ~(DEG_FREE_KNOWN | DEG_FREE_EXACT); // NOT defined.
+ }
+ }
+ } // (99)
+ else
+ { // is EOF so NO (df)
+ types |= DEG_FREE_KNOWN ; // deg_free IS implicitly known == 0.
+ // degreesOfFreedom = 0U; // Default == 1 observation.
+ }
+ } // eof
+ } // eof
+#ifdef UNC_TRACE
+ {
+ std::cerr << "\n### unc_input:""\n""\t" "value "
+ << value
+ << ", stdDev " << stdDev
+ << ", df " << dec << degreesOfFreedom << ", "
+ << showUncTypes(types) << ", "
+ << showUncFlags(static_cast<unsigned short>(is.iword(uncFlagsIndex)))
+ << std::endl;
+ } // trace
+#endif
+ // Restore is stream flags - if altered.
+} // void unc_input(double&, double&, unsigned short&, unsigned short&, std::istream&);

Added: sandbox/SOC/2007/quan/boost/quan/impl/unc_output.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/impl/unc_output.ipp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,552 @@
+/*! \file unc_print.cpp
+ \brief Output of uncertain values.
+ \details Definitions of unc_input declarations in unc.hpp.\n
+ Outline:
+ ~~~~~~~~
+ 1 Get ios info: width, fill & precision, save to restore..
+ 2 Get the requested info from uncflags.
+ 3 Get the value, stddev, degfree & uncTypes..
+ 4 Check value & stdDev for Nan, inf, zero, neg.
+ 5 Determine significant digits and stdDeviation significant digits.
+ 6 Round.
+ 7 Determine padding.
+
+ Output.
+ ~~~~~~
+ Output leading padding.
+ output rounded value & exponent.
+ output +/- value, if requested.
+ output trailing padding, if required.
+ Output degrees of freedom, if required.
+
+ Record width used etc.
+*/
+
+// Copyright Paul A. Bristow 2009, 2012.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/quan/unc.hpp>
+
+#include <boost/math/special_functions/fpclassify.hpp>
+ //using boost::math::isnan;
+ //using boost::math::isinf;
+ //using boost::math::isfinite;
+ //using boost::math::isnormal; // isfinite and not denormalised.
+
+#include <boost/math/special_functions/sign.hpp>
+ // using boost::math::signbit;
+ // using boost::math::sign;
+ // using boost::math::copysign;
+
+// Restore ios fill and precision, and set width to zero, as if used.
+#include <boost/io/ios_state.hpp>
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+ // using std::stringstream;
+
+/*!
+ \brief Output to stream given value as a decimal digit string,
+ rounding properly using the uncertainty information in stdDev,
+ and optionally including uncertainty as +/-, and degrees of freedom,
+ with addition control from additional unc stream manipulators.
+
+ \param value Mean or most likely value.
+ \param stdDev Uncertainty estimate as standard deviation.
+ \param degFree Degrees of freedom -1. (Default zero for 1 observation).
+ \param uncTypes 16 Uncertain type flags about the value.
+ \param os Output stream, default is to `std::ostream`.
+ \exception Throws `std::bad_alloc()` if 'os::iword' has not been initialised correctly,
+ or has been corrupted.
+*/
+void unc_output(double value, // Mean or most likely value.
+ float stdDev, // Standard deviation (uncertainty).
+ unsigned short int degFree, // Degrees of freedom -1.
+ unsigned short int uncTypes, // 16 Uncertain type flags.
+ std::ostream& os = std::cout) // Output stream.
+{
+ using boost::math::isnan;
+ using boost::math::isfinite;
+
+ using std::setprecision;
+ using std::setw;
+ using std::resetiosflags;
+
+ using std::istream;
+ using std::ostream;
+ using std::ios_base;
+ using std::char_traits;
+ using std::cout;
+ using std::cerr;
+ using std::cin;
+ using std::endl;
+ using std::flush;
+ using std::ws;
+ using std::streamsize;
+ using std::boolalpha;
+ using std::dec;
+ using std::hex;
+ using std::showbase;
+ using std::fixed;
+ using std::scientific;
+ using std::right;
+ using std::showpos;
+ using std::noshowpos;
+ using std::noshowbase;
+ using std::noshowpoint;
+ using std::showpoint;
+ using std::noadjust; // Restore to default state.
+ using std::nofixed; // Restore to default state.
+ using std::noscientific; // Restore to default state.
+ using std::defaultfloat; // Restore fixed & scientific to default state.
+ using std::hexbase;
+ using std::lowercase;
+
+ // Check iwords are setup correctly.
+ if ((os.iword(zeroIndex) != indexID) || (os.iword(topIndex) != indexID))
+ { // iwords are corrupt!
+ cerr << "\n!!! unc_output: " "iword corrupt!" << endl;
+ outUncValues(os, cerr); // Log all the iword values to cerr.
+ os << "?????" << endl;
+ throw std::bad_alloc(); // Or which other exception?
+ // This means the function `setUncDefaults(os)` has not been called for the stream os!
+ return; // int notOK might be better?
+ }
+ // References to os.iword()
+ long& uncWidth = os.iword(uncWidthIndex); // Width required for uncertain value.
+ long& oldUncWidth = os.iword(oldUncWidthIndex); // Width required for previous uncertain value.
+ long& uncFlags = os.iword(uncFlagsIndex); //
+ long& Width = os.iword(widthIndex); // Width specified by setw(99).
+ long& oldWidth = os.iword(oldWidthIndex); // width previously specified by setw(99)
+ long& setSigDigits = os.iword(setSigDigitsIndex); // Specified number of digits to use for value.
+ long& setStdDevSigDigits = os.iword(setUncSigDigitsIndex); // Specified number of digits to use for sd.
+ long& setScale = os.iword(setScaleIndex); // Scale factor, stored by `<< setScale(6)`
+ // Only actually scale multiple, if also request to set scale with `out << setscale ...`
+
+ // bools showing output requirements specified using unc additional ostream manipulators.
+ // Note that these bools are NOT initialised here,
+ // assuming compiler will warn if used before being initialised.
+ /*
+ \var bool isNoisyDigit
+ \brief Add an extra 'noisy' guard digit to reduce risk of information loss.
+ */
+ bool isNoisyDigit;
+ bool isPlusMinus;//!< Uncertainty as +/- is required too (but ignore if value is exact or integer).
+ bool isUppercase; //!< Exponential format is, for example, 1E6 else 1e6.
+ bool isScientificFormat; //!< Taken to mean that exponential format wanted (always possible).
+ bool isShowPoint; //!< Means decimal point is always shown, for example 900. even if not needed.
+ bool isShowPos; //!< Show + sign always because ios flag was set with `<< showpo`s.
+ bool isFixed; //!< `os << fixed ...` ios decimal fixed d.dddd format (rather than scientific).
+ bool isWidthSet; //!< `os << setw(9)` has prescribed a width (rather than default width == 0).
+ bool isNoAdjust; //!< std = default but unc usage not defined yet, center?
+ bool isRightJustify; //!< right justify, prepend leading pad before. `<< right << ...`
+ bool isLeftJustify; //!< left justify, append trailing pad after. `<< left ...`
+ bool isInternalJustify; //!< Not defined yet, but use to center in field?
+ bool isCenter; //!< center if BOTH left and right specified.
+ bool isAlign; //!< Align on decimal point?
+
+ // bools showing state of arguments value, stdDev, df.
+ // Note that these bools are NOT initialised here,
+ // assuming the compiler will warn if use before initialized.
+ // They all need to be 'global' to `unc_output`.
+ bool isValueExact = false; //! value is exact (integer, rational, zero stdDev or noplus & nominus).
+ bool isValueInteger = false; //! value is an integer, or stdDev = 0.f.
+ bool isUncKnown = false; //!< StdDev or uncertainty is valid.
+ bool isValueNaN = false; //!< value is NaN.
+ bool isValueInfinite = false; //!< Value is infinite (postive or negative).
+ bool isValueNegative = false; //!< Value is negative.
+ bool isValueZero = false; //!< Value is zero.
+ bool isValueNearZero = false; //!< So near to zero that can't calculate relative stdDev.
+ bool isValueTooBigforUnc = false; //!< Magnitude > 1e38
+ bool isValueTooBigforSI = false; //!< magnitude > 1e24
+ bool isValueZeroFractional = false; //!< Value to output has a non-zero fractional part.
+ bool isStdDevNaN = false; //!< StdDev is NaN.
+ bool isStdDevInf = false; //!< StdDev is inf.
+
+ //int sigDigits = std::numeric_limits<double>::max_digits10; // Default significant digits for value.
+ // Show all potentially significant?
+ int sigDigits = 6; // Default significant digits for value.
+ // For non-zero: 3 means ddd0. or ddd. or dd.d or d.dd or d.dd or 0.ddd or 0.0ddd ...
+ // For zero, sigDigits = 1 means just 0, 2 means 0.0, 3 means 0.00 ...
+ // If sigDigits < 0 means significant digits is undefined.
+ int stdDevSigDigits = 1; // Default significant digits for stdDev.
+
+#ifdef UNC_TRACE
+ { // Log the unc_output arguments:
+ std::cerr << "\n <<< unc_output: "
+ << setprecision(2 + std::numeric_limits<double>::digits * 3010/10000) // aka max_digits10
+ << value // scientific if necessary.
+ << ", stdDev " << stdDev
+ << ", df " << degFree
+ << " ";
+ // and log the info from the unc iwords:
+ outUncFlags(uncFlags, std::cerr);
+ std::cerr << " ";
+ outUncTypes(uncTypes, std::cerr);
+ outUncValues(os, std::cerr);
+ }
+#endif
+ //const int savedUncFlags = uncFlags; // Save to restore.
+ //const int savedUncWidth = os.iword(uncWidthIndex); // Save to restore.
+ // Why restore? - passed by value, so can alter if want to.
+
+ // Width, precision, flags & fillChar data from stream os. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ streamsize iosWidth = os.width(); //!< \warning Width must be read BEFORE any use of os
+ // which would reset width back to zero!
+ // & prevent any ios formatting during os << ...
+ // because unc_output does all its own formatting.
+ isWidthSet = (iosWidth > 0); // For example by os << setw(99)
+ // Fixed width field suits tables.
+ // For example: os << setw(10) means fit into a width of 10, with padding if necessary.
+ // stream width <= 0 means no justification or padding.
+ // Since default width = 0 after each item output so ostream,
+ // defaults to flex format, suitable for flexible non-tabulated layout.
+ const std::streamsize iosPrecision = os.precision();
+ // Number of significant decimal digits prescribed by \c setprecision(int), Default is 6.
+ const char iosFillChar = os.fill(); // Default is a space.
+ // Save format flags from \c ostream, so can restore on exit, and set \c ios default values.
+ const int iosFlags = os.flags(); // Save fmtflagsin case need to restore.
+ os.width(0); // Would be zeroed by any previous use like << avalue ...
+ os.flags(ios_base::dec | ios_base::skipws); // All other format flags are zero (cleared bits).
+ // Leaving fill and precision as on entry.
+#ifdef UNC_TRACE
+ { // Log ios fillchar, precision & width.
+ // fill char set by \c os.fill('~'); or \c << \c setfill('~')
+ // precision by \c << setprecision(10) or cout.precision(10),
+ // width by \c setw(10) or \c cout.width(10)
+ std::cerr << " IOstream: "
+ "fill char " << hex << showbase
+ << int(iosFillChar) << space
+ << '\'' << iosFillChar<< '\''<< dec
+ << ", precision " << iosPrecision << ", width " << iosWidth << ", "
+ << std::endl;
+ std::cerr << " "; outFmtFlags(os.flags(), std::cerr, ".\n");
+ std::cerr << " "; outIOstates(os.rdstate(), std::cerr, ".\n");
+ } // trace
+#endif
+
+ // Get print format requirements from std::ios flags. ****************************
+ isUppercase = static_cast<bool>(iosFlags & ios_base::uppercase); // E not e.
+ // TODO No mechanism to change uppercase at present in round_* functions.
+ isScientificFormat = static_cast<bool>(iosFlags & ios_base::scientific); // exp format wanted.
+ isFixed = static_cast<bool>(iosFlags & ios_base::fixed); // `<< fixed` Fixed format wanted.
+ // means d.dddd format wanted, if possible, rather than scientific or exp format.
+ isNoAdjust = !static_cast<bool>(iosFlags & ios_base::adjustfield); // `<< noadjust`
+ // no adjustfield flags are set (default, and == << right - a waste!).
+ isLeftJustify = static_cast<bool>(iosFlags & ios_base::left);
+ // left justify, append trailing padding with fillchar after.
+ isRightJustify = static_cast<bool>(iosFlags & ios_base::right);
+ // right justify, prepend leading padding with fillchar before.
+ isInternalJustify = static_cast<bool>(iosFlags & ios_base::internal);
+ // IO streams use to output fill char between sign and 1st digit.
+ // And meaning of more than one bit is specially defined for unc_output:
+ isCenter = isLeftJustify && isRightJustify;
+ // center if BOTH left and right ios specified.
+ // Done with ` << ` center rather than `<< left << right ... `.
+ isAlign = isInternalJustify && isLeftJustify && isRightJustify;
+ // Align decimal point with previous value?
+
+ isShowPoint = static_cast<bool>(iosFlags & ios_base::showpoint);
+ // Means decimal point is always shown, for example 900. even if not needed.
+ isShowPos = static_cast<bool>(iosFlags & ios_base::showpos);
+ // Show + sign always.
+
+ // Get print format requirements from unc flags.
+ isNoisyDigit = static_cast<bool>(uncFlags & noisyDigit); // `<< addNoisyDigit`
+ isPlusMinus = static_cast<bool>(uncFlags & plusMinus); // `<< plusminus`
+ // Uncertainty as +/- is required too (but ignore if integer).
+
+ int exponent = 0; // To hold calculated 10 ^ exponent.
+ size_t used = 0; // Count of chars actually output to stream os.
+
+#ifdef UNC_TRACE
+ { // Log display options.
+ std:: cerr << " " "Display: "
+ << (isPlusMinus ? "+/- " : "")
+ << (isUppercase ? "upper " : "lower ")
+ << (isScientificFormat ? "expFormat " : "")
+ << (isWidthSet ? "set_width" : "")
+ << (isFixed ? "fix " : " ")
+ << (isNoAdjust ? "no_adjust " : "")
+ << (isLeftJustify ? "left " : "")
+ << (isRightJustify ? "right " : "")
+ << (isInternalJustify ? "internal " : "")
+ << (isCenter ? "center " : "")
+ << (isAlign ? "align " : "")
+ << (isShowPos ? "show_+ " : "" )
+ << (isShowPoint ? "show_. " : "")
+ << std::endl;
+ } // trace
+#endif
+
+ // Check value, stdDev & unc types for finite, zero, integer, exact. @@@@@@@@@@@@@@@@@@@@@@@@@@@@
+
+ // Check value features first.
+ const double savedValue = value; // Save in case need original (signed & unscaled).
+ isValueInteger = static_cast<bool>(uncTypes & VALUE_INTEGER); // Explicitly flagged as integer.
+ isValueExact = static_cast<bool>
+ (( ((uncTypes & (UNC_NOPLUS | UNC_NOMINUS)) == (UNC_NOPLUS | UNC_NOMINUS))// Both NOPLUS & NOMINUS bits set == 1,
+ || (uncTypes & VALUE_EXACT) == VALUE_EXACT) // or flagged as exact VALUE_EXACT, like 2.54
+ || ((uncTypes & (VALUE_INTEGER | VALUE_RATIONAL)) != 0) ); // Both integers (99) & rationals (22/7) are implicitly exact,
+ // But zero values, for example 0.000 (implicitly +/- 0.0005) or 0. +/- 0.05f
+ // are NOT exact (nor integer), unless stdDev = 0.f, or integer constructed from "0".
+
+ if (isValueExact)
+ { // By convention, uncTypes take precedence over any value of stdDev.
+ // But should also cross-check if VALUE_EXACT and stdDev != 0.f
+ stdDev = 0.f; // Ensuring it is finite in test below.
+ degFree = (unsigned short)0;
+ // By convention, exact values have 1 reading & so degfree == 0
+ if (isValueInteger)
+ { // No +/- because is integer, even if requested y << plusminus.
+ isPlusMinus = false;
+ } //
+ } // isValueExact
+
+ // Check if value is finite.
+ if (!isfinite(static_cast<double>(value)))
+ { // (value == NaN) || (value == SNaN) || (value == INFINITY)
+ if (isnan(value))
+ { // NaN
+ isValueNaN = true;
+ isValueNegative = false; // By convention, only positive zero and positive NaNs.
+ }
+ else
+ { // If not NaN then assume + or - infinity.
+ isValueInfinite = true;
+ isValueNaN = false;
+ // Unlike zero and NaN, can have negative infinity.
+ } // isNaN?
+ isValueZero = false;
+ isValueExact = false;
+ isUncKnown = false;
+ } // value not finite.
+ else
+ { // value IS finite, so can test if value is negative or zero, too big or too small.
+ isValueInfinite = false;
+ isValueNaN = false;
+ isValueZero = (0. == value);
+ if (isValueZero)
+ { // Keep display of zero value simple (& avoid risk of divide by zero!).
+ isValueNegative = false; // By convention, only +0 and +NaNs.
+ isValueNearZero = true; // Use to avoid relative std deviation.
+ isScientificFormat = false;
+ exponent = 0;
+ } // is ZeroValue.
+
+ if (value < 0.)
+ { // is Negative (OK to use < 0. test here because have already eliminated NaN and inf).
+ isValueNegative = true;
+ value = fabs(value); // Can now ignore effect of negativeness, adding sign for output.
+ } // value < 0.
+
+ isValueNearZero = (value < numeric_limits<double>::min() * 10.);
+ // May cause divide-by-zero trouble if use relative std deviation.
+
+ } // value zero, finite, NaN, outsize tests.
+
+ // Check on features of stdDev.
+ isUncKnown = uncTypes && UNC_KNOWN; // Uncertainty is flagged as KNOWN from uncType,
+ // (but still need to check that stdDev is finite).
+ if (!isfinite(stdDev))
+ { // stdDev is NaN or infinity.
+ isValueInteger = false; // ???
+ isValueExact = false; // Uncertainty must be zero for exact, sp can't be exact if uncertainty is undefined, .
+ uncTypes &= ~(UNC_KNOWN | UNC_NOPLUS | UNC_NOMINUS | UNC_QUAN_DECIMAL | UNC_QUAN_BINARY | UNC_UNIFORM | UNC_TRIANGULAR);
+ // and clear many bits for unc_types which cannot be correct.
+ isUncKnown = false; // Despite uncType flag UNC_KNOWN.
+ if (isnan(stdDev))
+ {
+ isStdDevNaN = true; // (So uncertainty undefined)
+ // but value is OK, so leave the value as is.
+ }
+ else // If stdDev not NaN then assume stdDev is infinite (+ or -).
+ { // If stdDev == infinity, then, by convention, value == NaN.
+ value = numeric_limits<double>::quiet_NaN(); // So the value becomes undefined too.
+ isValueNaN = true;
+ isStdDevInf = true;
+ } // stdDev is NaN or infinity.
+ } // stdDev NOT finite.
+ else
+ { // stdDev is finite (normal case).
+ isStdDevInf = false;
+ isStdDevNaN = false;
+ isUncKnown = true;
+ if ((0.f == stdDev) && isUncKnown)
+ { // stdDev is finite zero (& uncertainty is known) so
+ isValueExact = true; // value explicitly exact.
+#ifdef UNC_TRACE
+ {
+ std::cerr << " " "StdDev exact value "<< value;
+ } // trace
+#endif
+ } // stddev finite
+ else
+ { // stdDev != 0, so value cannot be exact.
+ isValueExact = false;
+ }
+ } // End checks on stdDev.
+
+#ifdef UNC_TRACE
+ { // Show output settings.
+ std::cerr
+ << " " "Output Settings: " << boolalpha << dec
+ << (isWidthSet ? "width is set, " : "no width set, ")
+ << (isPlusMinus ? " +/- " : "")
+ << (isUppercase ? "upper " : "lower ")
+ << (isScientificFormat ? "expFormat " : "")
+ << (isFixed ? "fix " : " ")
+ << (isLeftJustify ? "left " : "")
+ << (isNoAdjust ? "no adjust " : "")
+ << (isRightJustify ? "right " : "")
+ << (isInternalJustify ? "int " : "")
+ << (isShowPos ? "show_+ " : "" )
+ << (isShowPoint ? "show . " : "")
+ << (isValueZero ? "isValueZero " : "" )
+ << (isValueNearZero ? "isValueNearZero " : "" )
+ << (isValueExact ? "isValueExact " : "" )
+ << (isValueInteger ? "isValueInteger " : "" )
+ << (isValueNegative ? "isValueNegative " : "" )
+ << (isValueInfinite? "isValueInfinite " : "" )
+ << (isValueNaN ? "isValueNaN " : "" )
+ << (isStdDevNaN ? "isStdDevNaN " : "" )
+ << (isValueTooBigforSI ? "Too_big for_SI " : "")
+ << (isValueTooBigforUnc ? "Too_big_for_unc " : "")
+ << (isUncKnown ? "isUncKnown " : "uncUnknown" )
+ << std::endl;
+
+ std::cerr << " " "Value " << setprecision(18) << value << (isValueNearZero ? "isValueNearZero " : "");
+ } // trace
+#endif
+ // Scale the value, if required by unc flags setScaled or autoScaled. __________________________
+ // 0 == scale10 means (not)scaled by unity. 3 means divided by 1000 ...
+ if (!isValueInteger && !isValueZero && !isValueInfinite && !isValueNaN)
+ { // autoscaled or set scaled.
+ // but NOT isValueInteger, so means output 10000 m not 10.000 km,
+ // nor zero because pointless.
+ } // if (isScaled && !isValueInteger)
+
+ // ScaledValue is in range OK, exponent == 0
+ // so find power of ten of ms digit, 9 = 10 ^ 0, 90 = 10 ^ 2
+ // int stdDevExponent = 0; // If value is d.d, then exponent = 0.
+
+ // Calculate how many significant digits for value, and then for stdDev.
+ // Or, if requested, use the set values.
+
+ // int sigDigits; // Significant digits for value,
+ // for example: 3 means ddd0. or ddd. or dd.d or d.dd or d.dd or 0.ddd or 0.0ddd ...
+ // For zero, sigDigits = 1 means just 0, 2 means 0.0, 3 means 0.00 ...
+ // int stdDevSigDigits; // Significant digits for stdDev.
+ if (isValueInteger)
+ { // Integer 9876
+ stdDevSigDigits = 0; // No uncertainty known!
+ // But even if << plusminus, do NOT output "9 +/- 0" for an integer.
+ // Do output decimal point if requested by showpoint.
+ // Do we want to scale integers if requested by << setscale? TODO
+ sigDigits = exponent + 1; // So for integers 1 to 9: exponent = 0 & sigDigits = 1,
+ // for integers 10 to 19, exponent = 1, sigDigits = 2 ...
+ isPlusMinus = false; // Never show "2 +/-0" for integer value 2.
+ // (even if requested with out << plusminus << integer ... !).
+ } // isValueInteger.
+ else if (isValueExact)
+ { // Show full precision, but NO trailing zeros, so get "2.54" not "2.5400000000000"
+ sigDigits = 1;
+ // sigDigits = numeric_limits<double>::digits10; // Typically 15 digits are guaranteed.
+ // (Although max_digits10 are perhaps significant).
+ // Show "+/-0" if requested for real exact for example: "2.54 +/-0"
+ // (unlike NOT for integer).
+ stdDevSigDigits = 0; // "+/-0" not "+/-0.", "+/-0.0", "+/-0.1" ...
+ exponent = 0;
+ } // isValueExact.
+
+ if (os.iword(uncFlagsIndex) && useSetSigDigits)
+ { // Use set sig digits instead of calculated from uncertainty.
+ sigDigits = setSigDigits;
+ os << setprecision(setSigDigits) << value;
+ }
+
+ // Inexact and known uncertainty (including 0.0000 +/- 0.00019 case).
+#ifdef UNC_TRACE
+ { // scaling.
+ std::cerr << std::setprecision(sigDigits+2) << dec
+ << " "
+ << ", sigDigits " << sigDigits
+ << ", stdDevSigDigits " << stdDevSigDigits;
+ if (os.iword(uncFlagsIndex) && useSetSigDigits);
+ { // Only if flag set.
+ std::cerr << ", setSigDigits " << setSigDigits;
+ }
+ if (os.iword(uncFlagsIndex) && setStdDevSigDigits))
+ { //
+ std::cerr << ", useSetUncSigDigits " << setStdDevSigDigits;
+ << std::endl;
+ }
+ } // trace
+#endif
+
+ const char signChar = (isValueNegative) ? '-': // Always show '-' sign.
+ (isShowPos ? '+' : // show '+' only if isShowPos.
+ //(isWidthSet ? ' ' : 0 ) ); // space where sign char would be only for isWidthSet.
+ (isWidthSet ? 0 : 0 ) ); // zero where sign char would be only for isWidthSet.
+
+ // Save previous before actually output anything, so can restore on exit.
+ os.iword(oldSigDigitsIndex) = os.iword(sigDigitsIndex); // Save previous sigDigitsIndex.
+ os.iword(sigDigitsIndex) = sigDigits; // Save or 'return' sigDigits used next.
+
+ // ################### Actually Output value (append +/- if isPlusMinus). ####################################
+
+#ifdef UNC_TRACE
+ {
+ std::cerr << " " " ios Width " << iosWidth
+ << ", ios fill char " << showbase << hex << int(iosFillChar) << dec
+ << (isprint(iosFillChar) ? iosFillChar : ' ')
+ << ", signChar (" << showbase << hex << int(signChar) << dec << noshowbase << ") " << ((signChar != 0) ? signChar : ' ')
+ << std::endl;
+ } // trace
+#endif
+
+ std::ostringstream oss; // Value etc string to really output, with pre & /or after padding, if necessary.
+
+ bool beenPointed = false; // Decimal point has not been output yet.
+ // Might use this later for alignment of table the decimal points.
+
+ if (isValueInfinite)
+ {
+ oss << ((isValueNegative) ? "-infinity" : "+infinity");
+ }
+ else if(isValueNaN)
+ {
+ oss << "NaN"; // "NaN"
+ }
+ boost::io::ios_precision_saver precision_saver(os); // Save and restore on exit.
+ boost::io::ios_flags_saver flags_saver(os);
+
+ // round here.
+ //os << val.value() << "(+/-" << val.uncertainty() << ")";
+
+ //os << oss.str(); // "1.23 +/- 0.1 (9) mV"
+
+ used = oss.str().size();
+
+#ifdef UNC_TRACE
+ {
+ std::cerr << " " << dec << used << " chars used in total." << std::endl;
+ } // trace
+#endif
+
+ os.iword(oldUncUsedIndex) = os.iword(usedIndex); // Save previous used.
+ os.iword(usedIndex) = static_cast<long>(used); // Record chars actually output to os.
+ // This may be needed to calculate layout of a table,
+ // Std behaviour is to return to default width.
+ // Field width reverts to its default behavior, width = 0
+ // (the necessary width) after one field has been printed,
+ // so must be last item before a ';' to be read. Not ideal!!
+ // os.width = savedWidth; // Restoring width is pointless.
+ os.flags(iosFlags); // Restore ios flags.
+} // void unc_output(double value, float stdDev,
+// unsigned short int degFree, unsigned short int uncTypes, ostream& os);

Added: sandbox/SOC/2007/quan/boost/quan/impl/xiostream.ipp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/impl/xiostream.ipp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,339 @@
+/*! \file
+ \brief Extra iostream manipulators.
+ \details Definitions of declarations in xiostream.hpp.
+
+ \author Paul A. Bristow
+
+*/
+// file /impl/xiostream.ipp
+
+// Copyright Paul A. Bristow 2009
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//#include <boost/quan/xiostream.hpp> // Declarations of items defined below.
+// included from this file.
+
+#ifndef XIOSTREAM_IPP
+#define XIOSTREAM_IPP
+
+#include <boost/math/special_functions/fpclassify.hpp>
+
+std::ios_base& lowercase(std::ios_base& _I)
+{ // lowercase is the inverse of std::ios_base::uppercase.
+ _I.unsetf(std::ios_base::uppercase); // Default is lowercase.
+ return _I;
+} // lowercase
+
+// Function to set base hex & showbase & uppercase too.
+// Usage: out << hexbase << ... for 1234ABCD
+// equivalent to out << hex << showbase << uppercase ...
+std::ios_base& hexbase(std::ios_base& _I)
+{
+ _I.setf(std::ios_base::hex | std::ios_base::showbase | std::ios_base::uppercase, // setbits,
+ std::ios_base::basefield | std::ios_base::showbase | std::ios_base::uppercase); // mask.
+ // Care: std::ios_base::basefield); doesn't set showbase & uppercase!
+ return _I;
+}
+
+// Manipulator template.
+// Copy of template for manipulator (from std iomanip)
+// Usage: omanip<int>setw(int);
+template<typename T> class omanip // Manipulator for ostream.
+{
+ friend std::ostream& operator<< (std::ostream&, const omanip<T>&);
+public:
+ omanip(std::ostream&(*f)(std::ostream&, T), T v) : func(f), val(v)
+ {
+ }
+private:
+ std::ostream&(*func)(std::ostream&, T); // Function like setw
+ T val; // Parameter like width.
+}; // class omanip
+// Could also provide an istream version for operator >>
+
+// Applicator is a class that stores a pointer to a function that takes
+// a reference to an std::ios_base (or derived translator) argument, and
+// an argument of the type for which the applicator is parameterized.
+// Applicator classes have the function call operator overloaded
+// so as to simulate a function call with the argument of the parameter type.
+// Use, for example: oapp<int> spaces(_spaces); // allows << spaces(5) ...
+// where function is std::ostream& _spaces(std::ostream&, int);
+
+// Global ostream applicator using template oapp instantiated for type int,
+// & initialised with the addresss of function with one int parameter.
+// Possible to use oapp<int> spaces(_spaces); which allows << spaces(5) ...
+// but instead spaces, stars & chars done a simpler way, see S Teale p 181-3.
+template<class T> class oapp // Applicator for ostream.
+{
+public:
+ oapp(std::ostream&(*f)(std::ostream&, T)) : func(f)
+ {
+ };
+ // : func(f) {} added from Watcom version to initialise & define.
+ omanip<T> operator()(T v)
+ {
+ return omanip<T>(func, v);
+ }
+private:
+ std::ostream&(*func)(std::ostream&, T);
+}; // class oapp
+
+// Template Manipulator Inserter <<
+template<class T> std::ostream& operator<< (std::ostream& os, const omanip<T>& m)
+{
+ (*m.func)(os, m.val);
+ return os;
+};
+
+// C++ Std Parameterless manipulators not used.
+// std::ostream& operator<<(std::ostream& (*)(std::ostream&) );
+// See \include\ostream for manipulator template eg endl
+// & instantiations of endl, ends, flush near end of file.
+// only narrow char instantiated here, may need wide version too.
+
+// Manipulator with no arguments which inserts into ostream.
+// See MSVC++ 7 "Writing your own manipulators without arguments".
+// No class derivation nor macros.
+// Relies on std::ostream defining overloading of operator<< to accept
+// function type, for example, std::ostream& bold(std::ostream&); declared in unc.h
+// inline std::ostream& ostream::operator<<(std::ostream& (__cdecl * _f)(std::ostream&)) { (*_f)(*this); return *this; }
+// inline std::ostream& ostream::operator<<(std::ios_base& (__cdecl * _f)(std::ios_base& )) { (*_f)(*this); return *this; }
+// Usage: cout << "regular" << bold << "now bold" << endl;
+// std::ostream& bold(std::ostream& os) // perhaps inline
+// {
+// return os << '\033' << '['; // Use if have ANSI terminal emulation.
+// }
+
+// Manipulators like dec, oct, dec ... see \include\std::ios_base
+// Parameterless manipulators like dec, hex ...
+// std::ios_base& (*)(std::ios_base&)
+// Pointer to function taking std::ios_base reference argument
+// & returning std::ios_base reference.
+// These apply to both istream and ostream.
+//
+// std::ostream& (*)(std::ostream&) and istream& (*)(istream&)
+// Pointer to function taking ostream (or istream) reference argument
+// & returning ostream (or istream) reference, but NOT BOTH.
+// Inserters and extractors:
+// std::ostream& operator<<( std::ios_base&(*)(std::ios_base&) )
+// istream& operator<<( std::ios_base&(*)(std::ios_base&) )
+// Eg std::ios_base& dec(std::ios_base& s){s.setf(std::ios_base::dec, std::ios_base::basefield);}
+
+spaces::spaces(int n) : num(n)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const spaces& s)
+{
+ for (int i = s.num; i > 0; i--) os << ' ';
+ return os;
+}
+
+tabs::tabs(int n) : num(n)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const tabs& s)
+{
+ for (int i = s.num; i > 0; i--) os << '\t';
+ return os;
+}
+
+stars::stars(int n) : num(n)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const stars& s)
+{
+ for (int i = s.num; i > 0; i--) os << '*';
+ return os;
+}
+
+// Two parameter manipulator chars (not using template, as spaces)
+// Usage: << chars(5,'_') ... for 5 underlines.
+chars::chars(int n, char c) : num(n) , character(c)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const chars& s)
+{
+ for (int i = s.num; i > 0; i--) os << s.character;
+ return os;
+}
+
+// Manipulator to set specified base and to show base letter O or X uppercase.
+// Usage: out << setupperbase(16) ...
+setupperbase::setupperbase(int b) : base(b)
+{ // Constructor.
+}
+
+std::ostream& operator<< (std::ostream& os, const setupperbase& s)
+{
+ os.setf(std::ios_base::showbase | std::ios_base::uppercase |
+ ( 16 == s.base ? 1 : // std::ios_base::hex :std::ios_base::oct;
+ 8 == s.base ? std::ios_base::oct : std::ios_base::dec) , // default dec if not 8 or 16
+ std::ios_base::basefield | std::ios_base::showbase | std::ios_base::uppercase ); // mask
+ return os;
+} // std::ostream& operator<< (std::ostream& os, const setupperbase& s)
+
+void outIOstates(std::ios_base::iostate rdState, std::ostream& os, const char* term)
+{ // Usages:
+ // Default logs cout iostate to cerr, for example "IOstate: good", or "IOstate: fail"
+ // outIOstates(); // Same as:
+ // outIOstates(cout.rdState(), cerr, ".\n");
+ // outIOstates(cin.rdState());
+ // outIOstates(cerr.rdState(), cout, ", ");
+ // outIOstates(cout.rdState(), cerr, " iostate.\n ");
+ std::ios_base::fmtflags const savedflags = os.flags(); // Save to restore.
+ // Clear any unused and invalid bits in rdState.
+ rdState &= std::ios_base::goodbit | std::ios_base::eofbit | std::ios_base::failbit | std::ios_base::goodbit;
+ // enum _Iostate {goodbit = 0x0, eofbit = 0x1, failbit = 0x2, badbit = 0x4, _Statmask = 0x7};
+ // but use std::ios_base::goodbit; for portability.
+ // MSVC /Dinkumware defines _Statmask 0x17, _Hardfail also added recently.
+ os << "rdState ("<< std::showbase << std::hex << rdState << ") " << std::dec ;
+ if (rdState == std::ios_base::goodbit)
+ {
+ os << "good"; // 1st so no leading space.
+ }
+ else
+ { // At least one bit set, so all need a space first.
+ if ((rdState & std::ios_base::eofbit) != 0)
+ {
+ os << " eof";
+ }
+ if ((rdState & std::ios_base::failbit) != 0)
+ {
+ os << " fail";
+ }
+ if ((rdState & std::ios_base::badbit) != 0)
+ {
+ os << " bad";
+ }
+ }
+ os << term; // eg "\n" or ", " or " ".
+ os.flags(savedflags); // Restore.
+} // outIOstates
+
+const char* fmtFlagWords[16] =
+{ // Descriptions of each bit.
+ "skipws", "unitbuf", "uppercase","showbase","showpoint","showpos","left","right",
+ "internal","dec","oct","hex","scientific","fixed","boolalpha", "?"
+ /*
+ enum _Fmtflags
+ { // Show action when bit set == 1
+ skipws = 0x0001, // Skip white space on input.
+ unitbuf = 0x0002, // Output each char - unbuffered.
+ uppercase = 0x0004,// Display uppercase A through F for hexadecimal values and E for scientific values
+ showbase = 0x0008, // Display numeric constants in a format that can be read by the C++ compiler.
+ showpoint = 0x0010, // Show decimal point and trailing zeros for floating-point values.
+ showpos = 0x0020, // Show plus signs (+) for positive values.
+ left = 0x0040, // Left-align values; pad on the right with the fill character.
+ right = 0x0080,// Right-align values; pad on the left with the fill character (default alignment).
+ internal = 0x0100, // Add fill characters after any leading sign or base indication, but before the value.
+ dec = 0x0200, // Format numeric values as base 10 (decimal) (default radix).
+ oct = 0x0400, // Format numeric values as base 8 (octal).
+ hex = 0x0800, // Format numeric values as base 16 (hexadecimal).
+ scientific = 0x1000,// Display floating-point numbers in scientific format.
+ fixed = 0x2000, // Display floating-point numbers in fixed format.
+ boolalpha = 0x4000, // Show bool as word true or false.
+ // 0x8000 un-used. // show as ?
+ adjustfield = 0x01c0,
+ basefield = 0x0e00,
+ floatfield = 0x3000,
+ _Fmtmask = 0x7fff,
+ _Fmtzero = 0
+ };
+ */
+}; // const char* fmtFlagWords
+
+void outFmtFlags(std::ios_base::fmtflags fmtFlags, std::ostream& os, const char* term)
+{// Usage: outFmtFlags(flags, cerr);
+ // For example, logs to cerr "FormatFlags: skipws showbase right dec"
+ // Defaults in xiostream.hpp:
+ // void outFmtFlags(fmtflags fmtFlags = cout.flags(), std::ostream& os = cerr, const char* term = ".\n");
+ const int count = 16; // because using unsigned short int.
+ std::ios_base::fmtflags flags = os.flags(); // save to restore.
+ fmtFlags &= static_cast<std::ios_base::fmtflags>(0x7FFF); // _Fmtmask // clear un-used bits.
+ os << "iosFormatFlags (" << std::showbase << std::hex << fmtFlags << std::dec << ")" ; // hex value.
+ if (fmtFlags != 0)
+ {
+ for(int i = 0, j = 1; i < count; ++i)
+ {
+ if ((fmtFlags & j) != 0)
+ {
+ os << ' ' << fmtFlagWords[i];
+ }
+ j <<= 1;
+ }
+ }
+ os << term; // eg "\n" or ". "
+ os.flags(flags); // Restore.
+} // outFmtFlags
+
+std::ostream& showiostate(std::ostream& os)
+{ // Show IO stream state in words for this stream.
+ // Usage: cout << showiostate ...
+ outIOstates(static_cast<std::ios_base::iostate>(os.rdstate()), os, ". ");
+ // May be problem with output if state is bad!
+ return os;
+}
+
+std::ostream& showformat(std::ostream& os)
+{ // Show IO stream format flags in words for this stream.
+ // Usage: cout << showformat ...
+ outFmtFlags(static_cast<std::ios_base::fmtflags>(os.flags()), os, ". ");
+ return os;
+}
+
+void setiosDefaults(std::ostream& os)
+{ // Return state and flags to same as when initialised.
+ // Would like to use std::ios_base::init, but is protected.
+ // See also setUncDefaults.
+ using std::ios_base;
+ // basic_streambuf<char, char_traits<char> >* os_buf = os.rdbuf();
+ // basic_ios<char, char_traits<char> >::init(os.rdbuf(), true);
+ // Cannot access protected member declared in class.
+ os.clear(std::ios_base::goodbit); // Clearing any 'bad' bits.
+ os.fill(' '); // Default fill char.
+ os.precision(6); // Default precision.
+ os.width(0); // Would be zeroed by any previous use like << 99 ...
+ os.flags(std::ios_base::dec | std::ios_base::skipws); // All others are zero (cleared bits).
+} // setiosDefaults(std::ostream& os)
+
+void outFpClass(double value, std::ostream& os);
+
+std::ostream& FPclass(std::ostream& os, double value)
+{ // Show Floating point type or value.
+ // Usage: cout << FPclass(NaN) ...
+ outFpClass(value, os);
+ return os;
+} // std::ostream& FPclass(std::ostream& os, double value)
+
+void outFpClass(double value, std::ostream& os = std::cerr)
+// Usage: outFpClass(x, std::cerr);
+{ // Custom outputs for NaN, inf ... (rather than default 1#IND ...)
+
+ if (boost::math::isfinite(value))
+ {
+ os << value;
+ }
+ else if (boost::math::isnan(value))
+ {
+ os << "NaN";
+
+ }
+ else if ( boost::math::isinf(value))
+ {
+ os << "inf";
+ }
+ else
+ {
+ os << "?" << value << "?";
+ }
+} // OutFpclass
+
+#endif // #define XIOSTREAM_IPP

Added: sandbox/SOC/2007/quan/boost/quan/meas.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/meas.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,109 @@
+/*! \file
+ \brief Class for measurement using uncertain class.
+ \details class meas with uncertain type UReal and measurement order & time-stamp.
+*/
+
+// meas.hpp
+// Copyright Paul A. Bristow 2012
+
+#ifndef MEAS_HPP
+#define MEAS_HPP
+
+#include <boost/date_time/gregorian/gregorian.hpp> // include all types plus i/o.
+#include <boost/date_time/posix_time/posix_time.hpp> // include all types plus i/o.
+
+#include <boost/quan/unc.hpp>
+
+// Declaration.
+//class Meas; // Measured uncertain value AND its id and order and/or time-date stamp.
+
+#include <iostream>
+ using std::ostream;
+ using std::istream;
+#include <string>
+ using std::string; // date notadate(not_a_date_time);
+
+typedef unc<false> uncun; // Uncertain Uncorrelated (the normal case).
+
+/*!
+ \brief Measured uncertain value AND its id and order and/or time-date stamp.
+*/
+
+class Meas : public uncun
+{
+ friend ostream& operator<< (ostream&, const Meas&);
+ friend istream& operator>> (istream&, Meas&);
+
+public:
+ //Meas(); // Constructor - all defaults.
+ Meas(double const d = 0.); // Constructor from double (no extra info).
+ //Meas::Meas(uncun u); // Constructor from uncertain uncun.
+ // Meas(int const); // Constructor from int - use automatic conversion int to double.
+ // Meas(uncun u, string id = "", boost::posix_time::ptime ti = boost::posix_time::not_a_date_time);
+ Meas(uncun u, string id = "", boost::posix_time::ptime ti = (boost::posix_time::not_a_date_time), int o = -1);
+ //Meas(uncun u, string id = "", int o = -1);
+ Meas(const Meas&); // Copy constructor.
+ ~Meas(); // Default destructor.
+
+ // Operators.
+ Meas& operator= (const Meas& rhs); //!< Assignment operator.
+ Meas& abs (const Meas& rhs); // abs assignment operator.
+ Meas& abs (Meas& rhs); // abs operator.
+
+ bool operator== (const Meas& p) const; // Equality operator.
+ bool operator!= (const Meas& p) const; // Inequality.
+ bool operator< (const Meas& rhs) const; // Used by less.
+ bool operator> (const Meas& rhs) const; // Used by greater.
+ Meas operator+ (const Meas&) const // Unary +
+ { // All members remain unchanged.
+ return *this;
+ }
+ Meas operator- (void) const // Unary -
+ { // uncun measValue;
+ Meas m(*this); // copy.
+ m.value(-m.value()); // Negate only the value.
+ return m;
+ }
+ Meas operator- (void) // Unary -
+ { // Avoid copy but cannot be const.
+ Meas m(*this); // copy.
+ m.value(-m.value()); // Negate only the value.
+ return *this;
+ }
+
+ // Meas Member functions.
+ // Note static as only one instance of functions for all Meas objects.
+ // Usage: Meas::lessU(a, b);
+ static bool less(const Meas& l, const Meas& r); // l < r value (ignoring uncertainty).
+ static bool lessU(const Meas& l, const Meas& r); // < uncertain value.
+ static bool less2U(const Meas& l, const Meas& r); // < 2 * uncertainty .
+ static bool precedes(const Meas& l, const Meas& r); // < order.
+ static bool earlier(const Meas& l, const Meas& r); // < time.
+ static bool greaterU(const Meas& l, const Meas& r); // > uncertain value.
+ static bool greater2U(const Meas& l, const Meas& r); // > 2 * uncertain value.
+ static bool equal_toUnc(const Meas& l, const Meas& r); //
+ static bool lessAbsM(const Meas& l, const Meas& r); // abs value < abs value.
+
+ // Meas Member variables.
+public: // Inconvenient to make private?
+ std::string id_; // Identification info, if any, else "".
+
+ // Time and order values could be:
+ // 1 no known order.
+ // 2 known order, but no times.
+ // 3 times, from which order can be calculated,
+ // or both order and times given, so may need to be checked for consistency.
+
+ int order_; // Index from 0 (or 1 perhaps?) -1 == unknown?
+ // time_t m_time; // Time too as time_t, notaTime if not known.
+ boost::posix_time::ptime time_; // Posix time from Boost.Date_time.
+}; // class Meas
+
+// Output and input operator<< & operator>>
+ostream& operator<< (ostream& os, const Meas& m);
+istream& operator>> (istream& is, Meas& m);
+
+// Definitions in meas.ipp.
+#include <boost/quan/impl/meas.ipp>
+
+#endif // MEAS_HPP

Added: sandbox/SOC/2007/quan/boost/quan/meas2.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/meas2.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,48 @@
+/*! \file
+ \brief Class for measurement using @b two uncertain class items.
+ \details class meas2 with @b two uncertain type UReal and measurement order & time-stamp.
+*/
+
+// meas2.hpp
+// Copyright Paul A. Bristow 2012
+
+#ifndef MEAS2_HPP
+#define MEAS2_HPP
+
+#include <boost/quan/meas.hpp>
+
+class meas2;
+
+class meas2
+{
+ friend ostream& operator<< (ostream&, const Meas&);
+ friend istream& operator>> (istream&, Meas&);
+
+ public:
+ //Meas(); // Constructor - all defaults.
+ meas2(uncun ux, uncun uy, string id = "", boost::posix_time::ptime ti= (boost::posix_time::not_a_date_time), int o = -1);
+ // Construct from two values and all other info
+
+ // Meas Member variables.
+public:
+ uncun m_uncx;
+ uncun m_uncy;
+
+ // Time and order values could be:
+ // 1 no known order.
+ // 2 known order, but no times.
+ // 3 times, from which order can be calculated,
+ // or both order and times given, so may need to be checked for consistency.
+
+ std::string m_id; // Identification info, if any, else "".
+
+ int m_order; // Index from 0 (or 1 perhaps?) -1 == unknown?
+ // time_t m_time; // Time too as time_t, notaTime if not known.
+ boost::posix_time::ptime m_time; // Posix time from Boost.Date_time.
+}; // class meas2
+
+// Output and input operator<< & operator>>
+ostream& operator<< (ostream& os, const meas2& m);
+istream& operator>> (istream& is, meas2& m);
+
+#endif // MEAS2_HPP
\ No newline at end of file

Added: sandbox/SOC/2007/quan/boost/quan/pair_io.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/pair_io.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,28 @@
+ /*! \file pair_io.hpp
+ \brief Provide operator<< to output pair, surrounded by < > and separated by comma,
+ for example: "<1.23, 4.56>".
+ Typically used to show confidence intervals around a mean.
+ \details Polite to keep this a private detail namespace to avoid clash with other implementations!
+ \author Paul A. Bristow
+ \date Oct 2009, 2012
+*/
+
+#include <utility>
+ // using std::pair;
+
+//
+template<typename charT, typename traits, typename T1, typename T2>
+inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const std::pair<T1, T2>& p)
+{
+ return os << "<" << p.first << ", " << p.second << '>'; // Separated by comma & space.
+}
+
+// Explicit specialization for pair of doubles.
+template<typename charT, typename traits>
+inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const std::pair<double, double>& p)
+{
+ return os << "<" << p.first << ", " << p.second << '>'; // Separated by comma & space.
+}
+
+
+

Added: sandbox/SOC/2007/quan/boost/quan/rounding.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/rounding.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,1458 @@
+/*!
+ \file
+ \brief Common rounding
+ \details
+ http://www.diycalculator.com/popup-m-round.shtml#A3
+ all rounding types, including round-to-half and asymmetric and symmetric versions.\n
+ http://www.chem1.com/acad/webtext/pre/mm3.html
+ "The purpose in rounding off is to avoid expressing a value to a greater degree of precision
+ than is consistent with the uncertainty in the measurement."
+ "Observed values should be rounded off to the number of digits
+ that most accurately conveys the uncertainty in the measurement."
+ \author Paul A. Bristow
+ */
+
+// \file rounding.hpp
+
+// Copyright Paul A. Bristow 2009, 2012.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+/*! \mainpage <b> Proper rounding testbed documentation. </b>
+ *
+ * \section intro_sec Introduction to proper rounding.
+
+ This is a testbed for the epsilon-Proper rounding for a few distributions
+ assumed to be appropriate for the data observations.\n\n
+ Based on:\n
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby \n
+ Measurement Science and Technolology, 11 (2000) pages 1659-1665.
+ ISSN 0957-0233 S0957-233(00)13838-X.\n
+ Proper rounding of the measurement results under normality assumptions.\n\n
+ Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result
+ under the assumption of uniform distribution, \n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 1 - 7.\n\n
+ Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result
+ under the assumption of triangular distribution, \n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 21 to 31.\n
+ */
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4127) // conditional expression is constant.
+#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored.
+//# pragma warning(disable: 4702) // unreachable code.
+//# pragma warning(disable: 4511) // copy constructor could not be generated.
+//# pragma warning(disable: 4512) // assignment operator could not be generated.
+//# pragma warning(disable: 4521) // alignment of a member was sensitive to packing.
+//# pragma warning(disable: 4121) // alignment of a member was sensitive to packing.
+//# pragma warning(disable: 4100) // unreferenced formal parameter.
+//# pragma warning(disable: 4701) // local variable may be used without having been initialized.
+//# pragma warning(disable: 4189) // local variable is initialized but not referenced.
+//# pragma warning(disable: 4996) // '' was declared deprecated.
+#endif
+
+#include <boost/math/tr1.hpp>
+// using boost::math::tr1::round; // round floating-point to integer.
+// using std::floor;
+// using std::pow;
+// using std::log10;
+
+#include <boost/math/special_functions/fpclassify.hpp>
+//using boost::math::isnan;
+//using boost::math::isinf;
+//using boost::math::isfinite;
+//using boost::math::isnormal; // isfinite and not denormalised.
+
+#include <boost/math/special_functions/sign.hpp>
+// using boost::math::signbit;
+// using boost::math::sign;
+// using boost::math::copysign;
+
+#include <boost/math/distributions/students_t.hpp>
+// using boost::math::students_t;
+#include <boost/math/distributions/normal.hpp>
+#include <boost/math/distributions/uniform.hpp>
+#include <boost/math/distributions/triangular.hpp>
+// using boost::math::normal;
+//#include "pair_io.hpp"
+// operator<<
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_floating_point.hpp> // is_floating_point trait
+#include <boost/concept_check.hpp>
+#include "boost/quan/xiostream.hpp" // Extra std items, defaultfloat & fixed.
+//#include "boost/quan/si_units.hpp"
+//#include "libs/quan/src/si_units.cpp"
+
+#include <iostream>
+//using std::cout;
+//using std::cerr;
+//using std::cin;
+//using std::endl;
+//using std::ends;
+//using std::dec;
+//using std::hex;
+//using std::fixed;
+//using std::left;
+//using std::right;
+//using std::showpoint;
+//using std::nofixed;
+//using std::noscientific;
+//using std::defaultfloat;
+//using std::noadjust;
+//using std::scientific;
+//using std::boolalpha;
+//using std::showpos;
+//using std::noshowpos;
+
+#include <iomanip>
+//using std::setprecision;
+//using std::setw;
+#include <string>
+//using std::string;
+
+#include <fstream> // for fstream
+//using std::fstream;
+//using std::ofstream;
+
+#include <sstream> // stream
+//using std::ostringstream;
+//using std::string;
+//using std::basic_string;
+//using std::ios_base;
+
+#include <limits>
+//using std::numeric_limits;
+
+#include <locale>
+// default loc for isdigit
+
+BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559); // Assume IEEE 754 ONLY.
+// _STATIC_ASSERT (numeric_limits<double>::is_iec559); // and MS STATIC assert.
+// Might also work by checking that std::numeric_limits is specialized?
+
+BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_specialized); //
+
+#ifdef BOOST_NO_CXX11_NUMERIC_LIMITS
+// No support for std::numeric_limits<double>::max_digits10,
+const unsigned int maxdigits10 = 2 + std::numeric_limits<double>::digits * 3010 / 10000;
+#else
+// std::numeric_limits<double>::max_digits10; IS supported.
+// Any noisy or guard digits needed to display any difference are included in max_digits10.
+const unsigned int maxdigits10 = std::numeric_limits<double>::max_digits10;
+#endif
+
+// Explicit specialization for pair of doubles.
+
+std::ostream& operator<<(std::ostream& os, std::pair<double, double>& p) { /*! Output a pair of `double`s, using < > angle brackets and comma separator, using current stream's precision..
+ \detail Explicit specialization for `std::pair` for `double`s.\n
+ For example: <97.8725, 157.798>
+ \param p Pair of doubles.
+ \param os std::ostream for string output.
+ */
+ return os << "<" << p.first << ", " << p.second << '>'; // Angle bracketed, separated by comma & space.
+}
+
+// Explicit specialization for pair of const doubles.
+
+std::ostream& operator<<(std::ostream& os, const std::pair<double, double>& p) { /*! Output a pair of `double`s, using < > angle brackets and comma separator, using current stream's precision..
+ \detail Explicit specialization for @b`const` `std::pair` for `double`s.\n
+ For example: <97.8725, 157.798>
+ \param p Pair of `double`s.
+ \param os `std::ostream` for string output.
+ */
+ return os << "<" << p.first << ", " << p.second << '>'; // Angle bracketed, separated by comma & space.
+}
+
+// Two rounding algorithms returning double values (not strings).
+template<typename FPT> FPT round_sig(FPT v, int n); // v rounded to n significant decimal digits.
+template<typename FPT> FPT round_to_n(FPT v, int p); // Round value v to p decimal digits *after the decimal point*.
+
+// Rounding algorithms returning strings.
+template<typename FPT> std::string round_f(FPT v, int sigdigits); // Round fixed (not-exponential) to sigdigits decimal digits to string.
+template<typename FPT> std::string round_e(FPT v, int sigdigits); // Round fixed (exponential) to sigdigits decimal digits to string.
+template<typename FPT> std::string round_ms(FPT v, int m); // Round not-exponential to order m.
+
+template<typename FPT>
+FPT round_sig(FPT v, int n) { /*! \brief Returns v rounded to n significant decimal digits.\n
+ http://www.jason.mock.ws/wordpress/2007/02/22/round-a-float-to-of-significant-digits,
+ David A. Pimentel
+ \details These use log10 and pow and so are vulnerable to binary rounding errors,
+ as the value may not be exactly representable for the type specified.
+ Should give the same value as printf precision.
+ (int)(x < 0 ? x - 0.5 : x + 0.5))
+ So do we need to do something different for negative doubles?
+ The difference between symmetric and asymmetric rounding?
+ */
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+
+ using std::pow;
+ using std::log10;
+ using std::ceil;
+ if (n < 0) { // Probably a program error, so might throw?
+ return 0;
+ } else if (n == 0) { // Might also be an error, but make some sense, so
+ return 0.;
+ } else if (n > std::numeric_limits<FPT>::digits10) { // We might use max_digits10, but only digits10 are guaranteed.
+ n = std::numeric_limits<FPT>::digits10;
+ return v; // or just return value as is?
+ }
+ if (v == 0) {
+ return 0.;
+ }
+ FPT l10 = log10(v);
+ int l = static_cast<int> (ceil(l10));
+ int pow10 = n - l;
+ FPT p10 = pow(10., pow10);
+ FPT f = v * pow(10., pow10) + 0.5;
+ f = floor(f);
+ FPT r = f / p10;
+ return r;
+ // return floor(v * pow(10., pow10) + 0.5) / pow(10., pow10);
+} // FPT round_sig(FPT v, int n)
+
+template<typename FPT>
+FPT round_to_n(FPT v, int p) { /*! Round value v to p decimal digits *after the decimal point*.
+ http://www.jason.mock.ws/wordpress/2007/02/22/round-a-float-to-of-significant-digits
+ \note These use log10 and pow and so are vulnerable to binary rounding errors,
+ as the value v may not be exactly representable for the type specified.
+ Should give the same value as printf precision.
+ */
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+
+ using std::pow;
+ return static_cast<FPT> (floor(v * pow(10., p) + 0.5) / pow(10., p));
+} // template<typename FPT> FPT round_to_n(FPT v, int p)
+
+template<typename FPT>
+std::string round_e(FPT d, int sigdigits) { /*! \brief Show only `sigdigits` digits, in minimal scientific or 'e' format only,
+ rounded asymmetric (round-half-up, arithmetic rounding).\n
+ Round asymmetric avoids values like 0.15,
+ which cannot be stored exactly in binary IEEE 754 floating-point format
+ and are stored internally as 1.499999999999, being rounded unexpectedly to 0.1 rather than 0.2.
+ For example: format -1.2345e12 or 1.2345e-123.
+
+ \note the difference in meaning of precision from default, fixed and scientific, for example:
+ `d = 19.99;` \n
+ `cerr << setprecision(2) << d << endl; // 20 // rounded`\n
+ `cerr << fixed << setprecision(1) << d << endl; // 20.0 - rounded up.`\n
+ `cerr << fixed << setprecision(2) << d << endl; // 19.99 - 2 digits after decimal point.`\n
+ `cerr << scientific << setprecision(2) << d << endl; // 2.00e+001 - 2 digits after decimal point`
+
+ \details Also remove all redundant exponent characters and digits,
+ See http://en.wikipedia.org/wiki/Rounding .
+
+ \note The normal rounding provided by C and C++ is chosen to avoid loss of accuracy and bias
+ in any further *binary* calculations.
+ The rounded decimal digit *strings* returned are provided solely for *b human viewing
+ and should NOT be used for input to other calculations when one or
+ two extra noisy digits are needed to avoid loss of information by rounding.
+ If it is necessary to provide a decimal digit string for input,
+ it should use `std::numeric_limits<FPT>::max_digits10` in C++0x,
+ or `2 + std::numeric_limits<FPT>::digits * 3010/10000`
+ if the platform implementation of C++ Standard IOstream library does not yet provide this.
+ For 64-bit double, `max_digits10` is 17, so write `cout.precision(17)`.
+ This will avoid any bias or loss of accuracy in statistical calculations caused by rounding.
+
+ \note The C++ Standard IOstream library does not specify any guarantee about input
+ from a decimal digits string to internal floating-point format like `double`.\n
+ The compiler will always convert a literal floating-point to the *nearest
+ representable value*, but the C++ Standard IOstream library is not required do this.
+ In particular, MSVC 8.0 (2007) and 10.0 (2010) do not quite always achieve this
+ for `defaultfloat` format -
+ about 1/3 third of significand values in the range 0.0001 to 0.003894 are not
+ input to the nearest representable double, but are 1-bit different.
+
+ It is impracticable to test all floating-point values in a useful time,
+ so random values were tested.
+
+ For details see:
+
+ http://lab.msdn.microsoft.com/productfeedback/viewfeedback.aspx?feedbackid=7bf2f26d-171f-41fe-be05-4169a54eef9e
+
+ aka http://tinyurl.com/mpk72
+
+ This is very significant if you wish to 'round-trip'
+ (outputting a value and reading it back in again)
+ for example with lexical_cast or using Boost.Serialization.
+ A test like
+
+ assert(value_output == value_reinput)
+
+ will fail *very* intermittently.
+
+ So if this is important to you, use the scientific (exponential) format
+ with precision max_digits10 (17 for double) where random tests have not revealed any differences.
+
+ Logic of using C++ std printf-style rounding to start with a decimal digit string with rounded value
+ of digits10, only the guaranteed correct digits
+ to get the best estimate of the digit to be used for the final rounding.
+ Hopefully, any imprecision caused by inexact presentation is (binary) rounded away.
+
+ \note Only lowercase letter e is used, and positive exponents are not preceeded by + sign,
+ and leading zeros are omitted.\n
+ This is done to make the display as compact as possible.\n
+ If a fixed width is needed, the user program must provide any necessary padding,
+ using the size (length) of the string.
+
+ \param d value to be converted to decimal digit string.
+ \param sigdigits number of significant digits to show in string.
+ \return std::string containing value rounded and converted to `sigdigits` decimal digits in exponential format.
+ */
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+
+ if (boost::math::tr1::isinf(d)) {
+ return (boost::math::tr1::signbit(d) ? "-Inf" : "Inf");
+ }
+ if (boost::math::tr1::isnan(d)) {
+ return (boost::math::tr1::signbit(d) ? "-NaN" : "NaN");
+ }
+ if (sigdigits <= 0) {
+ std::cout << "Trying to display " << sigdigits << " significant decimal digits!" << std::endl;
+ return ""; // Or throw?
+ }
+
+ //const unsigned int max_digits10 = 2 + std::numeric_limits<FPT>::digits * 3010/10000;
+ if (sigdigits >= std::numeric_limits<FPT>::digits10) // C++0X provides std::numeric_limits<double>::max_digits10;
+ {
+ sigdigits = std::numeric_limits<FPT>::digits10; // digits10 (15 for double) decimal digits
+ // *after* the decimal point, so a total of 16 digits (plus a decimal point).
+ }
+
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+
+ std::ostringstream ss;
+ ss << std::scientific // use 9.99e+123 format
+ << std::showpoint // force decimal point and trailing zeros.
+ //<< setprecision(sigdigits)
+ // output precision decimal digits *after the leading digit and decimal point*
+ // in scientific mode, so this is one more than significant digits.
+ // Or should this be digits10 so that any imprecision
+ // caused by inexact presentation is rounded away?
+ << std::setprecision(std::numeric_limits<FPT>::digits10) //
+ // output precision is
+ // decimal digits *after the leading digit and decimal point*, total digits10+1 digits.
+ << d;
+ std::string s = ss.str(); // "1.294567890123457e+006"
+ // std::cout <<'|' << s <<'|' << ' ' << s.size() << std::endl;
+ //assert(s.size() == std::numeric_limits<FPT>::digits10 + 1 + 1 + 5); // == 22 if positive
+
+ std::string::iterator is = s.begin(); // 1st most significant digit before decimal point.
+ if ((*is) == '-') { // Skip over minus sign.
+ // Can ignore + case as won't ever be output because default std::ostringstream is std::noshowpos.
+ is++;
+ }
+ char s1 = *is; // Copy 1st digit before decimal point.
+ std::string::iterator is1 = is; // Copy 1st digit before decimal point.
+ assert((*is1 >= '0') && (*is1 <= '9'));
+ is++; // Move to decimal point.
+ assert((*is) == '.');
+ // Do not delete decimal point - it will be needed.
+ std::string::iterator isp = is; // Decimal point. Implied position after 1st most significant digit is known.
+ assert((*isp) == '.');
+
+ // Read the exponent part first into an integer.
+ std::string::iterator se = is1 + std::numeric_limits<FPT>::digits10 + 2;
+ assert(*se == 'e');
+ se++; // skip 'e'.
+ // Read exponent into an integer.
+ bool neg_exp = ((*se) == '-') ? true : false;
+ se++; // Skip over sign of exponent.
+ std::locale loc;
+ int exp = 0;
+ do
+ {
+
+ if (std::isdigit(*se, loc))
+ {
+ exp = exp * 10 + (*se - '0');
+ }
+ se++;
+ }
+ while (se != s.end());
+
+ if (neg_exp)
+ {
+ exp = -exp; // Make exponent signed.
+ }
+
+ // std::cout << "Exponent " << ((neg_exp) ? '-' : '+') << exp << std::endl;
+
+ std::string::iterator is2 = is1 + 2; // 2nd digit (after decimal point).
+ assert((*is2 >= '0') && (*is2 <= '9'));
+ std::string::iterator isr = is2 + sigdigits - 1; // 2nd digit (after decimal point) if sigdigits == 1.
+ assert((*isr >= '0') && (*isr <= '9'));
+ int rounder = (*isr) - '0';
+ // std::cout << "rounder " << rounder << std::endl;
+ is = isr; // Least significant digit.
+ is--;
+ if (is == isp)
+ { // Skip back over decimal point.
+ is--;
+ }
+ assert((*is >= '0') && (*is <= '9'));
+
+ s.erase(isr, s.end()); // Erase all the insignificant trailing decimal digits, and exponent.
+
+ // Round the non-exponent part, in case a carry means we must increment the exponent.
+ // For example, 9.9e0 will round up to 10. and so become 1e1.
+ bool carry = false;
+ if (rounder >= 5) {
+ carry = true; // Increment next most significant digit.
+ do {
+ if (*is < '9') // 0 to 8.
+ {
+ (*is)++; // round up by 1.
+ carry = false;
+ } else if (*is == '9') {
+ *is = '0';
+ carry = true;
+ } else {
+ std::cout << "wrong ! *is = " << *is << std::endl;
+ break;
+ }
+ if (is == is1) { // No more significant digit(s).
+ break;
+ }
+ is--; // Next more significant digit.
+ if (is == isp) { // Skip over decimal point.
+ is--;
+ }
+ if (is == is1) {
+ break;
+ }
+ } while (carry == true);
+ } else { // Rounder = 0 to 4, so nothing to do.
+ carry = false;
+ }
+ if (carry == true) { // Add one to 1st most significant digit.
+ if (s1 == '9') { // Carry to most significant 1st digit '9' means now preceeded by a '1' digit.
+ *is1 = '1';
+ exp++; // Add one to signed exponent.
+ // What if it exceeds max exponent?
+ } else { // 0 to 8, so just add one.
+ (*is1)++;
+ }
+ }
+ if (exp != 0) { // Add e, - sign if necessary and exponent
+ s += ('e'); // Since the stream is not known, there is no way to know if to use uppercase 'E'.
+ if (neg_exp) { // Make unsigned.
+ s += ('-');
+ exp = -exp;
+ }
+ if (exp >= 100) { // Need exponent hundreds digit.
+ int ed = exp / 100;
+ s += static_cast<char> (ed + '0');
+ }
+ exp %= 100;
+ if (exp >= 10) { // // Need exponent tens digit.
+ int ed = exp / 10;
+ s += static_cast<char> (ed + '0');
+ }
+ exp %= 10; // // Always need exponent units digit.
+ s += static_cast<char> (exp + '0');
+ }
+ // std::cout << "s = " << s << std::endl;
+ return s; // Rounded decimal digits string.
+} // string round_e(FPT d, unsigned int sigdigits)
+
+template<typename FPT>
+std::string round_ms(FPT v, signed int m) { /*! \brief Round floating-point v (not-exponential) to order m. (m is the index of the rounder digit).
+ This is variously called 'common rounding', 'round_5_up'.
+ \details Gejza Wimmer, Viktor Witkovsky, Tomas Duby\n
+ Measurement Science and Technology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X\n
+ Proper rounding of the measurement results under normality assumptions.\n
+ Uncertainty of measurement -- Part 3: Guide to the expression of uncertainty in measurement (GUM:1995)\n
+ ISO Guide 98 (1995) and updated version 2008.\n\n
+
+ \note `m` is the index of the rounder digit, that is the just insignificant digit
+ used to decide if the m+1th digit is to be rounded up or left as is.
+ So `m == 0` means that the rounder digit is the units digits, used to round the tens digit,
+ `m == +1` the rounder is the tens digit, and the rounded digit is the hundreds digit
+ `m == -1` rounder is the tenths digit (0.1), rounding the hundredths digit (0.01).
+
+ (Other authors specify the nth digit to be significant, where n = m + 1).
+
+ \param v Value to convert to decimal digit string after rounding.
+ \param m Signed digit position to round.
+ \return `std::string` decimal digit string of rounded value.
+ */
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+
+ // Use Boost.Math portable functions for testing infinity, NaN and their signs.
+ using boost::math::signbit;
+ using boost::math::isnan;
+ using boost::math::isinf;
+ int is_neg = signbit(v);
+ if (isnan(v)) { //! \note that the most significant sign bit of NaN is recognized by using function signbit,
+ //! 'sign' of NaNs cannot reliably and portably be tested using "x < 0"
+ //! because all comparisons using NaN are false - by definition.
+ return (is_neg) ? "-NaN" : "NaN";
+ } else if (isinf(v)) {
+ return (is_neg) ? "-inf" : "inf";
+ }
+ // Treat denormal differently too?
+
+ // m can be up to about exponent 308.
+ // static const int maxDecimalDigits = 1 + 1 + numeric_limits<double>::max_exponent + (2 + numeric_limits<double>::digits * 3010/10000)+1+1;
+ // Number of decimal digits to display FPT max in fixed format with lots of trailing zeros & decimal point.
+ // ostringstream smax;
+ // smax << setprecision(17) << fixed << -numeric_limits<double>::max() << endl; // numeric_limits<double>::max() = 1.7976931348623157e+308 but using fixed.
+ // std::cout << smax.str() << std::endl;
+ //-179769313486231610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000
+ // std:: << "length of smax " << smax.str().size() << std::endl; // 329
+ // sign + max_digits10 (17+1 = 18) + 293 significant zeros + decimal point + 17 trailing digits (zeros).
+ // max_exponent = 308, so expect 308 +1 = 309 digits before decimal point.
+ // of these 309, 17 may be non-zero, but always have one digit so only 16, so 293 zeros.
+ // 329 is longest decimal digit string that possibly can be output with double exponent.
+ // But this function never wants to output the 'noisy' extra digits, so limit to digits10 not max_digits10.
+ // So want sign + digits10 (15)
+ // + (max_exponent10 - digits10) (308-15 = 293) significant zeros
+ // + decimal point,
+ // and upto digits10 trailing zeros.
+ static const int maxDecimalDigits = 1 + (std::numeric_limits<FPT>::max_exponent10
+ - std::numeric_limits<FPT>::digits10) + 1 + std::numeric_limits<FPT>::digits10;
+ //std::cout << "max dec " << maxDecimalDigits << std::endl; // 310
+
+ if (m > maxDecimalDigits) { // limit abs(m) to maxDecimalDigits.
+ m = maxDecimalDigits;
+ }
+ if (m < -maxDecimalDigits) {
+ m = -maxDecimalDigits;
+ }
+
+ std::ostringstream ss;
+ ss << std::scientific // Use scientific E format.
+ << std::showpoint; // Force decimal point and trailing zeros.
+ // skipws showpoint dec scientific
+
+ ss.precision(std::numeric_limits<FPT>::digits10); // Output digits10 precision decimal digits (and decimal point).
+ // std::numeric_limits<double>::digits10 is 15 for 64-bit double.
+ // output precision decimal digits *after the leading digit and decimal point*, total digits10+1 digits.
+ ss << v;
+ std::string s = ss.str();
+
+ std::string::iterator is = s.begin();
+ if ((*is) == '-') { // delete minus sign.
+ // Can ignore + case as won't ever be output as default std::ostringstream is std::noshowpos.
+ // is_neg = true; already noted above using signbit.
+ s.erase(is); // is++;
+ }
+ // std::cout <<'|' << s <<'|' << ' ' << s.size() << std::endl; // For example: |1.797693134862316e+308| 22
+ /*
+
+ MSVC always has 3 exponent digits
+ 4.206884193232336e+000
+ 1.797693134862316e+308
+
+ gcc can have two or three exponent digits.
+ 0.00000000000000000e+00
+ 1.23456789012345669e+00
+ 1.23456789012345666e+03
+ 1.23456789012345671e-03
+ 1.23456789012345658e+200
+ 1.23456789012345671e-200
+ */
+
+#ifdef _MSC_VER
+ if (s.size() != std::numeric_limits<FPT>::digits10 + 1 + 1 + 5) { // for double == 22 (would be 23 if value was negative, but we are only dealing with abs value).
+ // 1.23000000000000000e+00
+ outFmtFlags(ss.flags());
+ std::cout << "\n" << v << ", " << m << ", " << s << ", "
+ << s.size() << ", " << std::numeric_limits<FPT>::digits10 + 1 + 1 + 5 << std::endl;
+ assert(s.size() == std::numeric_limits<FPT>::digits10 + 1 + 1 + 5);
+ // This happens if type FPT passed is not floating point (integer?).
+ return s;
+ }
+#endif
+#ifdef __GNUC__
+ // Format varies with size of exponent - either two or three digits.
+ if ((s.size() != std::numeric_limits<FPT>::digits10 + 1 + 1 + 4) // e+00
+ && (s.size() != std::numeric_limits<FPT>::digits10 + 1 + 1 + 5)) // e+308
+ { // for double == 21 (would be 22 if negative).
+ outFmtFlags(ss.flags());
+ std::cout << "\n" << v << ", " << m << ", " << s << ", "
+ << s.size() << ", " << std::numeric_limits<FPT>::digits10 + 1 + 1 + 4 << std::endl;
+ return s;
+ }
+#endif
+ std::string::iterator is1 = s.begin(); // 1st digit.
+ assert(*is1 >= '0');
+ assert(*is1 <= '9');
+ is++;
+ assert(*is == '.');
+ s.erase(is); // Erase decimal point. Implied position after 1st most significant digit is known.
+ std::string::iterator ie = s.begin() + std::numeric_limits<FPT>::digits10 + 1;
+ assert(*ie == 'e');
+ std::string::iterator se = s.end(); // After last exponent digit.
+ se--; // Least significant exponent 'units' digit.
+ assert(*se >= '0');
+ assert(*se <= '9');
+ int exp = (*se - '0'); // Exponent units digit's value.
+ se--;
+ assert(*se >= '0');
+ assert(*se <= '9');
+ std::locale loc;
+ if (std::isdigit(*se, loc))
+ { // Exponent tens.
+ exp += (*se - '0') * 10; // Exponent tens.
+ }
+ se--; // Previous might be exponent hundreds digit (always for MSVC), or sign.
+ if (std::isdigit(*se, loc))
+ { // Exponent tens digit.
+ exp += (*se - '0') * 100; // Exponent hundreds.
+ se--;
+ }
+ if (*se == '-') {
+ exp = -exp;
+ } else if (*se == '+') {
+ exp = +exp;
+ } else {
+ std::cout << "Function round_ms expected digit or sign!" << *se << std::endl;
+ }
+ se--; // Must be the letter 'e' next forward.
+ // std::cout << "exponent " << exp << std::endl;
+ assert((*se == 'e') || (*se == 'E')); // Check is 'e' or 'E'.
+ s.erase(se, s.end()); // Delete all exponent field: "e+123" or "e-01".
+ // leaving an digits10 + 1 = 16 decimal digit string ,
+ // with implied decimal point after the 1st digit, for example 1234567890123456.
+ // std::cout << "digits string = " << s << std::endl;
+ // Now round the string at m.
+ int p = exp - m; // Offset.
+ if (p <= 0) {
+ return "0.";
+ }
+
+ std::string::iterator sr = s.begin(); //
+ int o = (exp - m);
+ assert(o > 0);
+ if (o > std::numeric_limits<FPT>::digits10) { // No rounding possible.
+ o = std::numeric_limits<FPT>::digits10;
+ }
+ sr += (o);
+ // sr* is the rounding digit d subscript m.
+
+ int rounder = *sr - '0'; // Rounding digit.
+ std::string::iterator sis = sr; // Note position of the insignificant trailing decimal digits.
+ s.erase(sis, s.end()); // Erase all the insignificant trailing decimal digits.
+
+ //sr--; // Least significant digit.
+ bool carry = false;
+ if (rounder >= 5) {
+ carry = true; // Increment next most significant digit.
+ do {
+ sr--; // more significant digit.
+ if (*sr < '9') // 5 to 8
+ {
+ (*sr)++; // round up by 1.
+ carry = false;
+ } else
+ if (*sr == '9')
+ { // 9 will cause a carry.
+ *sr = '0';
+ carry = true;
+ } else {
+ std::cout << "wrong ! *sr = " << *sr << std::endl;
+ break;
+ }
+ } while (carry == true && sr != s.begin());
+ } else { // nothing to do.
+ carry = false;
+ }
+ if (carry == true) { // Carry to most significant digit means now preceed by a '1' digit.
+ s.insert(s.begin(), '1');
+ exp++;
+ }
+ if (m >= 0) { // May need zeros before decimal point.
+ int z = exp - s.size() + 1; // Number of significant zeros before decimal point.
+ if (z > 0) { // More efficient to check if any zeros needed before calling insert?
+ s.insert(sis, z, '0'); // Insert any significant zeros.
+ }
+ } else {// Any trailing zeros are already in the string.
+ }
+ std::string::iterator sd = s.begin();
+ if (exp > 0) { // Will try to insert off the end of the string if > maxdigits10+1!
+ sd += exp + 1;
+ s.insert(sd, '.'); // Insert decimal point.
+ } else if (exp == 0) { //
+ sd += exp + 1;
+ s.insert(sd, '.'); // Insert decimal point.
+ } else { // exp < 0
+ // Zero before decimal point might be optional?
+ s.insert(sd, '0'); // Insert zero before point.
+ sd++;
+ s.insert(sd, '.'); // Insert decimal point.
+ sd++;
+ int z = -exp - 1;
+ if (z > 0) {
+ s.insert(sd, z, '0'); // Insert any zeros before significant digits (0.001234).
+ }
+ }
+ if (is_neg) {
+ s.insert(s.begin(), '-');
+ }
+ //std::cout << "Final digits string " << s << std::endl;
+
+ return s;
+} // template <typename FPT> string round_ms(FPT v, signed int m)
+
+bool scaled = true; // want to scale and use prefix to avoid >1000 or < 1.
+
+template <typename FPT>
+std::string round_f(FPT v, int sigdigits) { /*! \brief Round floating-point value `v` (fixed, not-exponential) to `sigdigits` significant digits.
+ This is variously called 'common rounding', 'round_5_up'.
+
+ \details Gejza Wimmer, Viktor Witkovsky, Tomas Duby\n
+ Measurement Science and Technology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X\n
+ Proper rounding of the measurement results under normality assumptions.\n
+
+ Uncertainty of measurement -- Part 3: Guide to the expression of uncertainty in measurement (GUM:1995)\n
+ ISO Guide 98 (1995) and updated version 2008.
+
+ \param v Value to be converted to a decimal digit string, rounded to sigdigits significant digits.
+ \param sigdigits Number of significant digits after rounding.
+ \return `std::string` containing decimal digit string, properly rounded.
+
+ \note All these functions are templated on floating-point type and are not intended to be called
+ (and thus instantiated) for integral (or other) types.
+ This is because the value will not be output in scientific format, assumed by the code.
+ A check is_floating_point == true is provide that will fail in debug mode.
+ (A compile time check would be better).
+ */
+
+ // Will fail if FPT is not a floating-point type (because will not output in scientific format!).
+ BOOST_STATIC_ASSERT(boost::is_floating_point<FPT>::value);
+
+ // Use Boost.Math TR1 portable functions for testing infinity, NaN and their signs.
+ using boost::math::signbit;
+ int is_neg = signbit(v);
+ using boost::math::isnan;
+ using boost::math::isinf;
+
+ if (isnan(v)) { // Note that the most significant sign bit of NaN is recognized by using function signbit.
+ return (is_neg) ? "-NaN" : "NaN";
+ // 'sign' of NaNs cannot reliably and portably be tested using "x < 0"
+ // because all comparisons using NaN are false - by definition.
+ } else if (isinf(v)) {
+ return (is_neg) ? "-infinity" : "infinity";
+ }
+ // Treat denormal differently too?
+
+ // sign + max_digits10 (17+1 = 18) + 293 significant zeros + decimal point + 17 trailing digits (zeros).
+ // max_exponent = 308, so expect 308 +1 = 309 digits before decimal point.
+ // of these 309, 17 may be non-zero, but always have one digit so only 16, so 293 zeros.
+ // 329 is longest decimal digit string that possibly can be output with double exponent.
+ // But this function never wants to output the 'noisy' extra digits, so limit to digits10 not max_digits10.
+ // So want sign + digits10 (15) + (max_exponent10 - digits10) (308-15 = 293) significant zeros + decimal point, and digits10 trailing zeros.
+ static const int maxDecimalDigits = 1 + (std::numeric_limits<FPT>::max_exponent10
+ - std::numeric_limits<FPT>::digits10) + 1 + std::numeric_limits<FPT>::digits10;
+ //std::cout << "max dec " << maxDecimalDigits << std::endl; // 310
+
+ /*! \note C++0X provides @c std::numeric_limits<double>::max_digits10;
+ which is maximum possibly significant,
+ but only @c digit10 are guaranteed to be significant,
+ so limit @c sigdigits to @c digits10 (15 for IEEE 64-bit double).
+ */
+ if (sigdigits > std::numeric_limits<FPT>::digits10) {
+ std::cout << "Maximum significant digits is " << std::numeric_limits<FPT>::digits10 << std::endl;
+ sigdigits = std::numeric_limits<FPT>::digits10; // digits10 (15 for double) decimal digits after the decimal point.
+ }
+
+ if (sigdigits < 0) { // Must be a mistake.
+ std::cout << "Trying to output " << sigdigits << " significant digits!" << std::endl;
+ return "";
+ } else if (sigdigits == 0) { // Might handle zero case differently from sigdigits < 0?
+ std::cout << "Trying to output zero significant digits!" << std::endl;
+ return "";
+ }
+ //else sigdigits > 0, so usable.
+
+ std::ostringstream ss;
+ ss << std::scientific // Use scientific format to get all the value as potentially significant decimal digits.
+ << std::showpoint // Force decimal point and trailing zeros.
+ << std::setprecision(std::numeric_limits<FPT>::digits10) // Output `digits10` precision decimal digits (and decimal point).
+ // `std::numeric_limits<double>::digits10` is 15 for 64-bit double.
+ // output precision decimal digits *after the leading digit and decimal point*, total digits10+1 digits (16 for double).
+ << v;
+ std::string s = ss.str(); // digit string like -1.797693134862316e+308.
+ std::string::iterator is = s.begin();
+ if ((*is) == '-') { // delete minus sign.
+ // Can ignore + case as won't ever be output as default std::ostringstream is std::noshowpos.
+ //is_neg = true; already noted using signbit.
+ s.erase(is); // is++;
+ }
+ // std::cout <<'|' << s <<'|' << ' ' << s.size() << std::endl; // |1.234567890123457e+000| 22
+ assert(
+ (s.size() == std::numeric_limits<FPT>::digits10 + 1 + 1 + 5) // == 22
+ ||( s.size() == std::numeric_limits<FPT>::digits10 + 1 + 1 + 4) // == 21
+ ); // == 21
+ // Might be only two exponent digits on some platforms.
+
+ std::string::iterator is1 = is; // 1st digit.
+ assert(*is1 >= '0');
+ assert(*is1 <= '9');
+ is++;
+ assert(*is == '.');
+ s.erase(is); // erase decimal point. Implied position after 1st most significant digit is known.
+ //std::cout << "digit & exponent string " << s << std::endl;
+
+ // Read the exponent part first into an integer.
+ std::string::iterator se = is1 + std::numeric_limits<FPT>::digits10 + 1;
+ std::string::iterator ie = is1 + std::numeric_limits<FPT>::digits10 + 1;
+
+ assert(*se == 'e');
+ se++; // skip 'e'.
+ // Read exponent into an integer.
+ bool neg_exp = ((*se) == '-') ? true : false;
+ se++; // Skip over sign of exponent.
+ std::locale loc;
+ int exp = 0;
+ do
+ {
+
+ if (std::isdigit(*se, loc))
+ {
+ exp = exp * 10 + (*se - '0');
+ }
+ se++;
+ }
+ while (se != s.end());
+
+ if (neg_exp)
+ {
+ exp = -exp; // Make exponent signed.
+ }
+
+ //std::cout << "exponent " << exp << std::endl;
+ //se = s.end();
+ //se -= 5;
+ s.erase(ie, s.end()); // delete everything from e to end, "e+123" or "e-01"
+ // leaving an digits10+1 decimal digit string,
+ // with implied decimal point after the 1st digit, for example 1234567890123457.
+ // std::cout << "decimal digits string " << s << std::endl;
+ // now round the string at nth decimal digit.
+
+ std::string::iterator sr = s.begin(); //
+ int o = sigdigits;
+ assert(o > 0);
+ if (o > std::numeric_limits<FPT>::digits10)
+ { // No rounding possible.
+ o = std::numeric_limits<FPT>::digits10;
+ }
+ sr += (o);
+ // sr* is the rounding digit d subscript sigdigits+1.
+
+ int rounder = *sr - '0'; // rounding digit.
+ std::string::iterator sis = sr; // Note position of the insignificant trailing decimal digits.
+ s.erase(sis, s.end()); // Erase all the insignificant trailing decimal digits.
+
+ //sr--; // Least significant digit.
+ bool carry = false;
+ if (rounder >= 5) {
+ carry = true; // Increment next most significant digit.
+ do {
+ sr--; // more significant digit.
+ if (*sr < '9') // 5 to 8
+ {
+ (*sr)++; // round up by 1.
+ carry = false;
+ } else if (*sr == '9') {
+ *sr = '0';
+ carry = true;
+ } else {
+ std::cout << "wrong ! *sr = " << *sr << std::endl;
+ break;
+ }
+ } while (carry == true && sr != s.begin());
+ } else { // nothing to do.
+ carry = false;
+ }
+ if (carry == true) { // Carry to most significant digit means now preceed by a '1' digit.
+ s.insert(s.begin(), '1');
+ exp++;
+ }
+ // Check if are to change exponent and use prefix,
+ // or to change to exponential format?
+ //int multiple3 = 0;
+ //bool is_scaled = false;
+ // if (scaled == true)
+ // { // If necessary change to use a prefix so value is in range 1.000000.. to 999.99999..
+ // if (exp > SImaxPowerTen)
+ // { // No SI names above yocto, so need to use exponential format 1.23e+25.
+ // }
+ // else if (exp < SIminPowerTen)
+ // { // No SI names below yotta, so need to use exponential format 1.23e-25.
+ // }
+ // else if (abs(exp) >= 3)
+ // { // Value >= 1000.0, so can use nearest abbreviation, kilo, mega...
+ // int powerten = exp / 3;
+ // multiple3 = powerten * 3;
+ // exp %= 3; // nearest 10^3 can only be 1.20, 12.0 120.0
+ ///*
+ // const char* symbol = SIsymbols[multiple3 + SImaxPowerTen];
+ // const char* prefix = SIprefixes[multiple3 + SImaxPowerTen];
+ // std::cout << powerten << ' ' << symbol << ' ' << prefix << std::endl;
+ //*/ is_scaled = true;
+ // }
+ // else if (exp < 0)
+ // { // value < 1.0000000000000
+ // }
+ // }
+ // Now have the rounded decimal digit string, but may need some zeros.
+ if (sigdigits >= 0) { // May need zeros *before* decimal point.
+ int z = exp - s.size() + 1; // Number of significant zeros before decimal point.
+ if (z > 0) { // More efficient to check if any zeros are needed before calling insert.
+ s.insert(sis, z, '0'); // Insert any significant zeros.
+ }
+ } else {// Any trailing zeros are already in the string.
+ }
+
+ std::string::iterator sd = s.begin();
+ if (exp > 0) {
+ sd += exp + 1;
+ s.insert(sd, '.'); // Insert decimal point.
+ } else if (exp == 0) { //
+ sd += exp + 1;
+ s.insert(sd, '.'); // Insert decimal point.
+ } else { // exp < 0
+ // Zero before decimal point might be optional?
+ s.insert(sd, '0'); // Insert zero before point.
+ sd++;
+ s.insert(sd, '.'); // Insert decimal point.
+ sd++;
+ int z = -exp - 1; // May need zeros after decimal point, before significant digit(s).
+ if (z > 0) {
+ s.insert(sd, z, '0'); // Insert any zeros before significant digit(s) (0.001234).
+ }
+ }
+ if (is_neg) {
+ s.insert(s.begin(), '-');
+ }
+ //if (is_scaled == true)
+ //{ // Append symbol and prefix and trailing space.
+ // bool add_symbol = true;
+ // // const char* symbol = SIsymbols[multiple3 + SImaxPowerTen]; // kilo, mega ...
+ // // const char* prefix = SIprefixes[multiple3 + SImaxPowerTen]; // k, M m ...
+ // // std::cout << ' ' << symbol << ' ' << prefix << std::endl;
+ // if (multiple3 != 0)
+ // {
+ // s.append(" "); // separator between last digit and symbol.
+ // s.append((add_symbol ? symbol : prefix));
+ // }
+ //}
+
+ //std::cout << "Final digits string " << s << std::endl;
+
+ return s;
+} // string round_f(FPT v, signed int m)
+
+
+// Round number v *at* d th decimal place.
+// Note d is different (roundED digit) from the Wimmer definition of m (roundER digit).
+
+inline double round_nth(double v, unsigned int d) { //! round value v to d digits after decimal point, using d+1 digit to round.
+ return std::floor(v * std::pow(10., static_cast<int> (d)) + 0.5) / std::pow(10., static_cast<int> (d));
+}
+
+// Three explicit versions which may be slightly more efficient.
+
+inline double round_1(double v) { //! round value v to 1 digit after decimal point, using 1st digit to round.
+ return std::floor(v * 10. + 0.5) / 10.;
+}
+
+inline double round_2(double v) { //! round value v to 2 digit2 after decimal point, using 2nd digit to round.
+ return std::floor(v * 100. + 0.5) / 100.;
+}
+
+inline double round_3(double v) { //! round value v to 3 digit2 after decimal point, using 3rd digit to round.
+ return std::floor(v * 1000. + 0.5) / 1000.;
+}
+
+enum distribution_type { /*! \brief Distribution type, encoded into two bits in `short int unc_types`.
+ \note `gaussian` name is chosen rather than `normal` to avoid name clash
+ from name of bit 11 and bit 12 in `enum unc_types`.
+ */
+ gaussian = 0, //!< `unc_types` bit 11 and bit 12 == 0, aka normal.
+ uniform = 1, //!< `unc_types` bit 11 == 1, aka rectangular.
+ triangular = 2, //!< `unc_types` bit 12 == 1.
+ undefined = 3 //!< `unc_types` bit 11 and bit 12 == '11' == 3.
+};
+
+double delta(double epsilon, double gamma, distribution_type distrib = gaussian) { /*! \brief Calculate Wimmer delta function using equation 24, p 1664.
+ \details Gejza Wimmer, Viktor Witkovsky, Tomas Duby\n
+ Measurement Science and Technology, 11 (2000) pages 1659-1665.
+ ISSN 0957-0233 S0957-233(00)13838-X.\n
+ Proper rounding of the measurement results under normality assumptions.\n
+ Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result under the assumption of uniform distribution,\n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 1 - 7.\n
+ Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result under the assumtpion of triangular distribution,\n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 21 to 31.\n
+
+ \param epsilon Proper-rounding increase of confidence interval because of rounding, must be positive and 'small'.
+ \note epsilon is usually 0.05 or 95%, values in range 0.2 to 0.01 make good sense,
+ 0.2 (80%) risks a fair bit of loss from rounding, 0.01 (1%) causes almost no loss.
+ \param gamma Ratio rounded / unrounded (gamma is assumed <= 1).
+ \param distrib Distribution type, normal or gaussian(default), uniform, triangular, or laplace.
+
+ \return Approximation of Wimmer delta function using equation 24, p 1664,
+ for normal distribution, and similar for triangular and uniform.
+ Returns -1 if epsilon is too 'tight' so must be increased for delta to be calculated.
+ Throwing an exception might be better here>
+
+ */
+ // gamma > rounded gamma (so gamma < 1.?)
+ // Approximation error is less than 0.0123 for 0.005 <= epsilon < 0.1
+ // and gamma > rounded gamma for this epsilon - see table 1.
+ // assert(gamma > rounded_gamma);
+
+ //assert (gamma <= 1);
+ using std::sqrt;
+ double d;
+ double x;
+ double threshold;
+ double sqrt_3 = 1.7320508075688772935274463415058723669428052543712;
+
+ // TODO use boost.math constant.
+
+ switch (distrib) {
+ case gaussian: // equation 24, p 1664.
+ // Gejza Wimmer, Viktor Witkovsky, Tomas Duby
+ // Measurement Science and Technology, 11 (2000) 1659-1665.
+ // ISSN 0957-0233 S0957-233(00)13838-X.
+
+ d = (1.348 + 0.9886 * epsilon + 0.2288 * sqrt(epsilon));
+ x = gamma - 1.0001 + 2.058 * epsilon - 1.93 * epsilon * epsilon;
+ if (x < (std::numeric_limits<double>::min)() * 100.) // Small value allows for approximation uncertainty.
+ { // Not possible to have epsilon this small!
+ threshold = x; // ???
+ std::cout << "Epsilon " << epsilon << " is too small for gamma rounded/unrounded ratio " << gamma << ", threshold is " << threshold << " for gaussian distribution." << std::endl;
+ // For example:
+ // "Epsilon 0.01 is too small for gamma rounded/unrounded ratio 0.981226, threshold is 0.99."
+ return -1.; // Not sure how to signal the problem here. Throw?
+ }
+ x = sqrt(x);
+ d = d * x;
+ return d; // sqrt(gamma - 1.0001 + 2.058 * epsilon - 1.93 * epsilon * epsilon);
+ break;
+ case uniform:
+ // Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result under the assumption of uniform distribution,
+ // Measurement Science Review, Vol 2, section 1, (2002), pages 1 - 7.
+ threshold = 1 - epsilon; // Wimmer equation 17, page 5
+ if (gamma < threshold) {
+ std::cout << "Epsilon " << epsilon << " is too small for gamma rounded/unrounded ratio " << gamma << ", threshold is " << threshold << " for uniform distribution." << std::endl;
+ return -1; // Not sure how to signal the problem here.
+ }
+ d = sqrt_3 * (gamma + 2 * epsilon - 1); // Wimmer equation 20, page 6.
+ return d;
+ case triangular:
+ // Gejza Wimmer, Viktor Witkovsky, Proper rounding of the measurement result under the assumtpion of triangular distribution,
+ // Measurement Science Review, Vol 2, section 1, (2002), pages 21 to 31.
+ threshold = (1 - gamma) / (1 + gamma);
+ if (epsilon < threshold) {
+ std::cout << "Epsilon " << epsilon << " is too small for gamma rounded/unrounded ratio " << gamma << ", threshold is " << threshold << " for triangular distribution." << std::endl;
+ return -1; // Not sure how to signal the problem here.
+ }
+ // d = sqrt(6 * (epsilon - ((1 - gamma) /(1 + gamma)))); // Wimmer equation 18, page 27.
+ d = sqrt(6 * (epsilon - threshold));
+ return d;
+ default:
+ // Might add one more (4th) distribution here - assuming distribution type is encoded using 2 bits in unc class.
+ return -1;
+ } // switch
+} // double delta(double epsilon, double gamma, distribution_type distrib = gaussian)
+
+double gamma(double rounded, double value) {/*! \brief Calculate Wimmer gamma rounded/unrounded function p 1664.
+ \details Measurement Science and Technolology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby
+ Proper rounding of the measurement results under normality assumptions.
+
+ \param rounded Value (as `double`) after rounding.
+ \param value Value (as `double`) before rounding. Assumes `rounded < unrounded value`.
+ \return Ratio rounded / value, a measure of loss of information caused by rounding.
+ */
+ // Is this OK for negative values? Need to check or swap so result is <= 1.
+ // Use abs?
+ if (value == 0.) { // Avoid divide by zero (or very close to zero too?).
+ return 0.;
+ }
+ double g = rounded / value;
+ if (g > 1.) { // This seems necessary for some cases???
+ //std::cout << "value " << value << ", rounded " << rounded << std::endl;
+ g = 1. / g;
+ }
+ if (g > 1.) { // This seems necessary for some cases???
+ std::cerr << "value " << value << ", rounded " << rounded << std::endl;
+ // assert(g <= 1.); // Assumes rounded < unrounded.
+ }
+
+ return g;
+} // double gamma(double rounded, double value)
+
+int round_m(double epsilon = 0.01, double sigma = 0., unsigned int sigma_sigdigits = 2U, distribution_type distrib = gaussian) { /*! \brief Calculate the Wimmer rounding digit m using delta and gamma functions p 1661, equation 12.
+ \details Measurement Science and Technology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby\n
+ Proper rounding of the measurement results under normality assumptions.
+
+ \param epsilon Rounding loss (as fraction) accepted (default is 0.01 or 1%).
+ \param sigma Uncertainty as standard deviation.
+ \param sigmasigdigits Number of significant decimal digits
+ for uncertainty to be rounded (range 1 to 4, default = 2), depending on degrees of freedom.\n
+ If degrees_of_freedom <= 2, then 1, else if degrees_of_freedom > 1000, then 3 else default = 2.
+ \param distribution_type Type of distribution (default gaussian, or triangular or uniform).
+
+ \return m Signed position of the digit to be used for rounding,
+ `m == 0` means use the units digit for rounding the tens digit.
+ */
+ if ((sigma_sigdigits < 1) || (sigma_sigdigits > 4)) { // sigma_sigdigits is too big to be plausible from the confidence interval of uncertainty.
+ sigma_sigdigits = 4; // or throw?
+ }
+ // \boost_1_40_0\libs\math\example\chi_square_std_dev_test.cpp
+
+ //Confidence level (two-sided) = 0.0500000
+ //Standard Deviation = 1.0000000
+ //_____________________________________________
+ //Observations Lower Upper
+ // Limit Limit
+ //_____________________________________________
+ // 2 0.4461 31.9102
+ // 3 0.5207 6.2847
+ // 4 0.5665 3.7285
+ // 5 0.5991 2.8736
+ // 6 0.6242 2.4526
+ // 7 0.6444 2.2021
+ // 8 0.6612 2.0353
+ // 9 0.6755 1.9158
+ // 10 0.6878 1.8256
+ // 15 0.7321 1.5771
+ // 20 0.7605 1.4606
+ // 30 0.7964 1.3443
+ // 40 0.8192 1.2840
+ // 50 0.8353 1.2461
+ // 60 0.8476 1.2197
+ // 100 0.8780 1.1617
+ // 120 0.8875 1.1454
+ // 1000 0.9580 1.0459
+ // 10000 0.9863 1.0141
+ // 50000 0.9938 1.0062
+ // 100000 0.9956 1.0044
+ // 1000000 0.9986 1.0014
+
+ // and in Owen L. Davies and Peter L. Goldsmith, Statistical Methods in Research and production, ISBN 0 05 002437, p 457 (1972)
+
+ // So for 2 observations, the uncertainty might be 30 times, or half the central estimate,
+ // meaning that a second digit is not likely to be significant.
+ // But for the more common several degrees of freedom,
+ // a second digit might be significant.
+ // So the ISO GUM pragmatically states that 2 significant decimal digits should be used for the standard uncertainty.
+ // It only when 1000 observations are available (and there are no problems with drift)
+ // a fractional relative standard deviation of uncertainty is about 0.05
+ // and that 3 significant decimal digits are needed avoid loss from rounding.
+ double sigma_rounded = round_sig(sigma, sigma_sigdigits);
+ // ISO GUM always rounds uncertainty to n=2 significant digits,
+ // but elsewhere Wimmer et al round to only *one* significant digit.
+ // So sigdigits is parameterized to allow variation from (possibly very many)
+ // (possibly known) degrees of freedom?
+
+ // Wimmer uses only one significant digit to round sigma, for reasons unclear.
+ // So tests that compare to the paper do not fail when epsilon has values in example 5, p1662.
+
+ double g = gamma(sigma_rounded, sigma);
+ // Check against limits in table 1, page 1662.
+ double gl;
+ double e = epsilon;
+ if (e >= 0.1) { // <= 10% loss from rounding accepted.
+ gl = 0.81271;
+ } else if (e >= 0.05) {
+ gl = 0.90175;
+ } else if (e >= 0.02) {
+ gl = 0.95951;
+ } else if (e >= 0.01) {
+ gl = 0.97954;
+ } else { // // <= 1% loss from rounding accepted.
+ gl = 0.98972;
+ }
+ if (gl > g) {
+ std::cout << "Cannot return a rounding m because epsilon " << e << " is too small!" << std::endl;
+ return -9999;
+ }
+ // Or throw?
+
+ double d = delta(epsilon, g, distrib);
+ if (d < 0.) { // Chosen epsilon is too small! (for example, e = 0.01 loss is too demanding, so try 0.02).
+ std::cout << "Cannot compute a rounding digit index m because epsilon " << epsilon << " is too small!" << std::endl;
+ return -9999; // or throw.
+ }
+ d = d * sigma_rounded / (5 * g); // Wimmer equation 12, page 1661.
+ // (and same for triangular distribution equation 10, page 24,
+ // and uniform distribution equation 22, page 6).
+ d = log10(d);
+ return static_cast<int> (floor(d)); // \return m the position of the digit to be used for rounding.
+ // m == 0 means use the units digit for rounding the tens digit...
+} // int round_m(double epsilon, double sigma, unsigned int sigdigits)
+
+std::string round_ue(double v, double sigma, double epsilon = 0.01, unsigned int sigdigits = 2U) { /*! \brief Properly round value to a decimal digit `std::string`.
+ \details Measurement Science and Technolology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.\n
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby,
+ Proper rounding of the measurement results under normality assumptions.
+ p 1661, equation 12.
+
+ \param v Central value, often estimate of mean.
+ \param sigma Uncertainty of value, usually standard deviation.
+ \param epsilon Fraction of loss of accuracy from rounding permitted (default 1%).
+ \param sigdigits Number of digits that are significant (default 2).
+
+ \return Decimal digit `std::string` containing rounded value.
+ */
+ //int round_m(double epsilon, double unc, unsigned int sigdigits, distribution_type t);
+ int m = round_m(epsilon, sigma, sigdigits, gaussian);
+ std::string r = round_ms(v, m);
+ return r;
+} // string round_ue(double v, double unc, double epsilon = 0.01, unsigned int sigdigits = 2U)
+
+std::pair<double, double> conf_interval(double mean, double sigma, double df = 1., double alpha = 0.05, distribution_type distrib = gaussian) { /*!
+ \brief Calculate confidence interval for chosen alpha confidence level and chosen distribution type.
+ \details Uses confidence interval equations from:\n
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby
+ Measurement Science and Technolology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.
+ Proper rounding of the measurement result under the assumption of gaussian distribution,\n
+ Confidence interval equation 6, p 1660.
+
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby\n
+ Measurement Science and Technolology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.\n
+ Proper rounding of the measurement result under the assumption of triangular distribution,\n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 21 to 31.\n
+ Confidence interval Equation 12, page 25.\n
+
+ Gejza Wimmer, Viktor Witkovsky,\n
+ Proper rounding of the measurement result under the assumption of uniform distribution,\n
+ Measurement Science Review, Vol 2, section 1, (2002), pages 1 - 7.\n
+ Confidence interval, page 5, equation 13.\n
+
+ \param mean Interval estimate for mean mu.
+ \param unc Standard uncertainty sigma from variance sigma &#x03C3; &#x00B2;.
+ \param df Degrees of freedom (usually number of observations -1).
+ \param alpha Confidence (0. < unc < 1.), typically 0.05 for 95% confidence.
+ alpha/2 = 0.025 quantile = -1.96, and 1 - alpha/2 is 1.96 for normal distribution,
+ so typically confidence interval is roughly twice unc either side (+ or - ) of mean.
+ \param distrib distribution type, gaussian(default), uniform, triangular, laplace.
+ \return Confidence interval upper and lower limits as a `std::pair` of doubles.
+ */
+ assert(alpha >= 0.);
+ assert(alpha <= 1.);
+ std::pair<double, double> ci;
+ switch (distrib) {
+ case gaussian:
+ { // Gejza Wimmer, Viktor Witkovsky, Tomas Duby
+ // Measurement Science and Technolology, 11 (2000) 1659-1665. ISSN 0957-0233 S0957-233(00)13838-X.
+ // Wimmer p 1660, equation 6.
+ using boost::math::normal;
+ normal dist; // zero mean and unit sd. == normal dist(0., 1.);
+ // Divide alpha by 2 because estimating upper and lower bounds.
+ double t = quantile(complement(dist, alpha / 2));
+ // std::cout << t << endl; // 1.95996 for alpha 0.05
+ // one-sided confidence interval.
+ double u = (df > 1) ? sigma / sqrt(df) : sigma;
+ double w = t * u; //
+ ci.first = mean - w;
+ ci.second = mean + w;
+ return ci;
+ }
+ break;
+ case triangular:
+ { // Gejza Wimmer, Viktor Witkovsky,
+ // Proper rounding of the measurement result under the assumption of triangular distribution,
+ // Measurement Science Review, Vol 2, section 1, (2002), pages 21 to 31.
+ // Confidence interval Equation 12, page 25.
+ using boost::math::triangular;
+ // boost::math version of triangular includes the mode c, as well as the limits a and b
+ // We really want the symmetric_triangular, but approximate with a = -1, c = 0 and b = +1.
+ // This NOT the boost::math default.
+ // Or could implement symmetric_triangular?
+ double u = (df > 1) ? sigma / sqrt(df) : sigma;
+ static const double sqrt_6 = 2.4494897427831780981972840747058913919659474804966; // sqrt(6)
+ triangular dist(-sqrt_6, 0., +sqrt_6); // Wimmer page 23, below eq 6.
+ double tlo = quantile(complement(dist, alpha / 2));
+ double thi = quantile(dist, alpha / 2);
+ // Wimmer page 24, quantile function (cdf inverse), equation 8.
+ ci.first = mean - tlo * u;
+ ci.second = mean - thi * u;
+ return ci;
+ }
+ case uniform: // aka rectangular distribution.
+ { // Gejza Wimmer, Viktor Witkovsky,
+ // Proper rounding of the measurement result under the assumption of uniform distribution,
+ // Measurement Science Review, Vol 2, section 1, (2002), pages 1 - 7.
+ // Confidence interval, page 5, equation 13.
+ static const double sqrt_3 = 1.7320508075688772935274463415058723669428052543712; // sqrt(3)
+ double u = (df > 1) ? sigma / sqrt(df) : sigma;
+ using boost::math::uniform;
+ uniform udist(-sqrt_3, +sqrt_3);
+ double tlo = quantile(complement(udist, alpha / 2)); // effectively quantile(1 - alpha/2)
+ double thi = quantile(udist, alpha / 2);
+ ci.first = mean - tlo * u;
+ ci.second = mean - thi * u;
+ return ci;
+ }
+ default: // As yet undefined distribution.
+ ci.first = std::numeric_limits<double>::quiet_NaN();
+ ci.second = std::numeric_limits<double>::quiet_NaN();
+ break;
+ } // switch (distribution_type)
+ return ci;
+} // std::pair<double, double> conf_interval(double value, double unc, double alpha = 0.05)
+
+static const double sqrt_2 = 1.4142135623730950488016887242096980785696718751217; // sqrt(2)
+static const double sqrt_6 = 2.4494897427831780981972840747058913919659474804966; // sqrt(6)
+static const double oneDivSqrtSix = 0.40824829046386301636621401245098189866099124674943; // 1/sqrt(6)
+static const double oneDivTwoSqrtSix = 0.20412414523193150818310700622549094933049562337472; // 1/(2*sqrt(6))
+static const double sqrt_3 = 1.7320508075688772935274463415058723669428052543712; // sqrt(3)
+
+double cdf_uni(double z) { /*! Cumulative distribution Function of uniform distribution Un(-sqrt_3, + sqrt_3),
+ with an expectation of mean zero and variance unity.
+ Gejza Wimmer & Victor Witkovsky, Measurement Science Review, volume 2 section 1 2002, page 3, equation 5.
+ \return Cumulative distribution Function of uniform distribution.
+ */
+ if (z <= -sqrt_3) {
+ return 0.;
+ } else if (z >= sqrt_3) {
+ return 1.;
+ } else if (z == 0.) {
+ return 0.5;
+ }
+ return (z + sqrt_3) / (2 * sqrt_3);
+} // double cdf_uni(double z)
+
+double quantile_uni(double alpha) { /*! Quantile of uniform distribution Uniform(-sqrt_3, + sqrt_3), expectation or mean zero and variance unity.
+ Wimmer & Witkovsky, Measurement Science Review, volume 2 section 1 2002, page 3, eq 6.
+ \return Quantile of uniform distribution.
+ */
+ static const double sqrt_3 = 1.7320508075688772935274463415058723669428052543712; // sqrt(3)
+ assert(alpha >= 0.);
+ assert(alpha <= 1.);
+ return sqrt_3 * (2 * alpha - 1);
+} // double quantile_uni(double alpha)
+
+double cdf_tri(double z) { /*! Cumulative distribution function CDF of triangular distribution.
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby,
+ Proper rounding of the measurement result under the assumption of triangular distribution,
+ Measurement Science Review, Vol 2, section 1, (2002), page 24, equation 7.
+
+ \param z
+ \return CDF of triangular distribution.
+ */
+
+ if (z < -sqrt_6) {
+ return 0.;
+ } else if (z > sqrt_6) {
+ return 1.;
+ } else if (z == 0.) { // Or might check if very near zero too?
+ return 0.5;
+ }
+ double zz = oneDivTwoSqrtSix * z * z;
+ if (z < 0.) {
+ return 0.5 + oneDivSqrtSix * (z + zz);
+ } else { // if (z > 0.)
+ return 0.5 + oneDivSqrtSix * (z - zz);
+ }
+} // double cdf_tri(double z)
+
+double quantile_tri(double alpha) { /*! Quantile or Inverse of cumulative distribution function CDF of triangular distribution.
+ Gejza Wimmer, Viktor Witkovsky, Tomas Duby,
+ Proper rounding of the measurement result under the assumption of triangular distribution,
+ Measurement Science Review, Vol 2, section 1, (2002), page 24, equation 8.
+
+ \param alpha Confidence level.
+ \return Quantile or Inverse of cumulative distribution function CDF.
+ */
+ assert(alpha >= 0.);
+ assert(alpha <= 1.);
+
+ if (alpha < 0.5) { // 0<= alpha < 0.5
+ return sqrt_6 * (sqrt(2. * alpha) - 1.);
+ } else { // 0.5 < alpha < 1.
+ return sqrt_6 * (1. - sqrt(2. * (1. - alpha)));
+ }
+} // double quantile_tri(double z)
+
+void out_confidence_interval(std::pair<double, double> ci, int m, std::ostream& os = std::cout) { /*! Output to os, confidence interval enclosed in brackets and separated by comma.
+ The precision is controlled by the rounding order `m` used for the mean
+ but with one extra decimal digit of precision, so rounding to m-1 th place.
+ For example: <99.5, 156.5> rounding to -1 position
+ (where the mean was rounded with m == 0,
+ using the units digit to round the tens digit to "128.")
+
+ \param ci Confidence interval or limits.
+ \param m Signed position for rounding.
+ \param os `std::ostream` for output.
+ */
+ std::streamsize osp = os.precision(); // Save to restore.
+ os.precision(3); // Uncertainty always rounded to 2 decimal digits.
+ using boost::lexical_cast;
+ os << "<" << lexical_cast<double>(round_ms(ci.first, m - 1)) << ", "
+ << lexical_cast<double>(round_ms(ci.second, m - 1)) << ">";
+ os.precision(osp); // Restore saved.
+} // void out_confidence_interval(std::pair ci)
+
+void out_value_limits(double mean, double unc, std::pair<double, double> ci, int m, std::ostream& os = std::cout) { /*! Output mean, uncertainty and confidence interval.
+ For example: \verbatim 128. +/- 15 <99.5, 156.5> \endverbatim
+
+ \param mean Mean or central estimate of value.
+ \param unc Uncertainty estimate as standard deviation.
+ \param Signed position for rounding.
+ \param m
+ \param os `std::ostream` for output.
+ */
+ std::streamsize osp = os.precision(); // Save to restore.
+ os.precision(2); // Uncertainty always rounded to 2 decimal digits.
+ double unc_rounded = round_sig(unc, 2); // Round to 2 significant digit - ISO rules.
+ // TODO increase here if noisydigit wanted,
+ // and/or if degress of freedom > 100.
+ os << round_ms(mean, m) << " +/- " << unc_rounded;
+ os.precision(6); //
+ using boost::lexical_cast;
+ os << " <" << lexical_cast<double>(round_ms(ci.first, m - 1)) << ", "
+ << lexical_cast<double>(round_ms(ci.second, m - 1)) << ">";
+ os.precision(osp); // Restore saved.
+} // void out_value_limits
+
+void out_value_df_limits(double mean, double unc, int degfree = 1, std::ostream& os = std::cout) { /*! Output mean, uncertainty and confidence interval.
+ For example: \verbatim 128. +/- 15 <99.5, 156.5> \endverbatim
+
+ \param mean Mean or central estimate of value.
+ \param unc Uncertainty estimate as standard deviation.
+ \param Signed position for rounding.
+ \param m
+ \param os `std::ostream` for output.
+ */
+ std::streamsize osp = os.precision(); // Save to restore.
+
+ int round_m(double epsilon, double unc, unsigned int sigdigits, distribution_type t);
+ // int round_m(double epsilon = 0.01, double unc = 0., unsigned int uncsigdigits = 2U, distribution_type distrib = gaussian)
+
+ double e = 0.01;
+ int m = round_m(e, unc, 2U, gaussian);
+
+ std::pair<double, double> ci;
+ ci = conf_interval(mean, unc, degfree);
+
+ os.precision(2); // Uncertainty always rounded to 2 decimal digits.
+ double unc_rounded = round_sig(unc, 2); // Round to 2 significant digit - ISO rules.
+ // TODO increase here if noisydigit wanted,
+ // and/or if degress of freedom > 100.
+ os << round_ms(mean, m) << " +/- " << unc_rounded;
+ os.precision(6); //
+ using boost::lexical_cast;
+ os << " <" << lexical_cast<double>(round_ms(ci.first, m - 1)) << ", "
+ << lexical_cast<double>(round_ms(ci.second, m - 1)) << ">";
+ os.precision(osp); // Restore saved.
+} // void out_value_limits
+
+// Above is missing degrees of freedom included in unc type.

Added: sandbox/SOC/2007/quan/boost/quan/si_units.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/si_units.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,281 @@
+/*!
+ \file
+ \brief SI Unit, names and abbreviations & conversion factors.
+
+ \details
+ See NIST 811 Special publication, Barry N Taylor (1995)
+ "Guide for the Use of the International System of Units (SI)
+ & ISO 31, a closely aligned document.
+ NIST version contains more on non-SI units and many useful notes.
+ */
+
+// Data & code to show units in si_units.cpp which includes this header.
+// Changed to unit starting with capital so time doesn't clash with C time()
+
+// SIunits.hpp
+
+// Copyright Paul A. Bristow 2009, 2012.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef SIUNITS_HPP
+#define SIUNITS_HPP
+
+#ifdef _MSC_VER
+# pragma once
+#endif
+
+#include <iostream> // Used by show units functions.
+using std::ostream;
+using std::string;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::size_t;
+
+const unsigned int notOK = 0xffffffff;
+
+const int maxPowerTen = 38;
+// == std::numeric_limits<float>::max_exponent10;
+// == FLT_MAX_10_EXP in float.h, so can represent FLT_MAX = 3.402823466e+38F;
+// to FLT_MIN_10_EXP in float.h, so can represent FLT_MIN = 1.175494351e–38F;
+// Done to limit the size of the power of Ten lookup table below,
+// and make code same if store value in a 32-bit double.
+// For real-life data, value of a unit is unlikely to exceed 10**38,
+// despite DBL_MAX_10_EXP == 308.
+
+extern const double powersOfTen [maxPowerTen + 1 + maxPowerTen];
+ // 1 is middle zeroth power.
+const int maxRounds = 17;
+extern const double rounds[maxRounds];
+
+const int maxPowerTens = maxPowerTen + 1 + maxPowerTen;
+const int SImaxPowerTen = 24; // Define array sizes.
+// SImaxPowerTen < maxPowerTen, until new names invented for more units.
+const int SIminPowerTen = -24; // yotta & min 10**-24
+const char* SIprefixes[]; // [0] to [48], countof = 49 (defined in si_units.cpp).
+const char* SIsymbols [];
+const int SImaxPowers = SImaxPowerTen + 1 + SImaxPowerTen;
+const int SIprefixesLength = SImaxPowerTen + 1 + SImaxPowerTen;
+// = sizeof SIprefixes /sizeof (const char*);
+
+struct SImultiple;
+
+// Fundamental units: Mass, Length, Time, Charge, Temperature, Luminous Intensity & angle.
+
+struct unit
+{
+public:
+ const char* unitOf; // "mass", "length", "time" ...
+ // unsigned char here causes need to int( )
+ // better to use short int?
+ // if const.
+ // C2552: non-aggregates cannot be initialized with initializer list.
+ // but can't see why - looks aggregate enough to me.
+ unsigned char unitSINameCount; // Countof SI unitName (meter = 5 + 1 = 6).
+ // = length of SIunitsNames[0] ????????? not used and wrong?
+ unsigned char unitAbbrevCount; // Count of chars in abbreviation (Hz = 2).
+ unsigned char unitNamesCount; // Count of units (no plurals or aliases or abbreviations)
+ // : meter, feet, inch...
+ // = length of array unitNames.
+ unsigned char unitsNamesCount; // Total number of all names for all units.
+ // (including plurals, abbreviations & aliases).
+ // None of these include terminating zero.
+ // Can't be const or triggered C2552 - wrongly?
+ // So instantiate as const unit ...
+ const int* unitLengths; // Count of aliases & abbreviations for each unit.
+ const char** SIunitNames; // SI or preferred unit, for example: "meter"
+ // SI unit MUST be always FIRST in list of unitNames = unitsNames[0],
+ // & SI abbreviation second.
+ const char* SIunitAbbrev; // "m", "Hz" = SIunitNames[1];
+ const char*** unitNames; // "meter", "feet", "mile" ...
+ // By convention, unitNames[0] is the base or full unit name, like meter,
+ // & unitNames[1] is the abbreviation, like m.
+ const double* unitToSIfactors; // factors to convert to SI unit.
+ // Dimensions here? - see project algebra, but not workable with MSVC++5SP3.
+};
+
+// Attempts to define a structure
+// const char s[];
+// const int l; // const here produces C2552
+// failed for compiler reasons - Quincy GNU seems to allow.
+// so for now keep array lengths separate from arrays themselves.
+
+// Definitions in SIunits.cpp for separate compilation.
+
+// Dimensionless units.
+extern const int noUnitCount;
+extern const char* noUnits [];
+extern const unit noUnit;
+extern const int perCentUnitCount;
+extern const char* perCentUnits [];
+extern const int perMilleUnitCount;
+extern const char* perMilleUnits [];
+extern const int perMillionUnitCount;
+extern const char* perMillionUnits[];
+extern const int perBillionUnitCount;
+extern const char* perBillionUnits [];
+extern const int perTrillionUnitCount;
+extern const char* perTrillionUnits [];
+extern const char** dimlessNoUnits [];
+extern const int dimlessUnitsCounts[];
+extern const double NoUnitsFactors [];
+extern const unit noUnit;
+
+// Units of mass: gram, kg, ton, cwt, lb, oz...
+extern const int massUnitCount;
+extern const int gramMassUnitCount;
+extern const char* gramMassUnits [];
+extern const int tonMassUnitCount;
+extern const char* tonMassUnits[];
+extern const int cwtMassUnitCount;
+extern const char* cwtMassUnits[];
+extern const int lbMassUnitCount;
+extern const char* lbMassUnits [];
+extern const int ozMassUnitCount;
+extern const char* ozMassUnits [];
+extern const char** massUnits [];
+extern const int massUnitsCounts [];
+extern const double massToSIfactors[];
+extern const unit mass;
+
+// Units of Length.
+extern const int lengthUnitCount; // meter, mile, yard, feet, inch, point
+extern const int meterLengthUnitCount;
+extern const char* meterLengthUnits[];
+extern const int mileLengthUnitCount;
+extern const char* mileLengthUnits[];
+extern const int yardLengthUnitCount;
+extern const char* yardLengthUnits [];
+extern const int feetLengthUnitCount;
+extern const char* feetLengthUnits [];
+extern const int inchLengthUnitCount;
+extern const char* inchLengthUnits [];
+extern const int pointLengthUnitCount;
+extern const char* pointLengthUnits [];
+extern const double lengthToSIfactors[];
+extern const char** lengthUnits [];
+extern const int lengthUnitsCounts[];
+extern const unit length;
+
+// Units of time: second, minute, hour ...
+extern const int timeUnitCount;
+extern const int secondTimeUnitCount;
+extern const char* secondTimeUnits [];
+extern const int secondTimeUnitCount;
+extern const char* secondTimeUnits [];
+extern const int minuteTimeUnitCount;
+extern const char* minuteTimeUnits [];
+extern const int hourTimeUnitCount;
+extern const char* hourTimeUnits [];
+extern const int dayTimeUnitCount;
+extern const char* dayTimeUnits [];
+extern const int monthTimeUnitCount;
+extern const char* monthTimeUnits [];
+extern const int yearTimeUnitCount;
+extern const char* yearTimeUnits [];
+extern const int fortnightTimeUnitCount;
+extern const char* fortnightTimeUnits [];
+extern const double timeToSIfactors[];
+extern const char** timeUnits [];
+extern const int timeUnitsCounts [];
+extern const unit Time; // Upper case to avoid clash with C global time.
+// time() is in C time.h
+
+// Units of current: amp
+extern const int currentUnitCount;
+extern const int ampCurrentUnitCount;
+extern const char* ampCurrentUnits[];
+extern const double currentToSIfactors [];
+extern const char** currentUnits [];
+extern const int currentUnitsCounts [];
+extern const unit current;
+
+// Units of Temperature: degress Kelvin & Celsius
+extern const int temperatureUnitCount;
+extern const int kTemperatureUnitCount;
+extern const char* kelvinTemperatureUnits[];
+extern const int cTemperatureUnitCount;
+extern const char* celsiusTemperatureUnits[];
+extern const int fTemperatureUnitCount;
+extern const char* fahrenheitTemperatureUnits[];
+extern const double temperatureToSIfactors[];
+extern const char** temperatureUnits[];
+extern const int temperatureUnitsCounts [];
+extern const unit temperature;
+
+// Units of substance: Mole.
+extern const int substanceUnitCount; // just moles
+extern const int molSubstanceUnitCount;
+extern const char* molSubstanceUnits[];
+extern const double substanceToSIfactors[];
+extern const char** substanceUnits [];
+extern const int substanceUnitsCounts [];
+extern const unit substance;
+
+// Units of luminous intensity: candela ...
+extern const int lumintensityUnitCount;;
+extern const int candelaLumintensityUnitCount;
+extern const char* candelaLumintensityUnits[];
+extern const double lumintensityToSIfactors[];
+extern const char** lumintensityUnits [];
+extern const int lumintensityUnitsCounts [];
+extern const unit lumintensity;
+
+// Frequency: Hertz.
+extern const int freqUnitCount;
+extern const int hertzFreqUnitCount;
+extern const char* hertzFreqUnits [];
+extern const double freqToSIfactors [];
+extern const char** freqUnits [];
+extern const int freqUnitsCounts [];
+extern const unit freq;
+
+ // Charge: Coulomb.
+extern const int chargeUnitCount;
+extern const int coulombChargeUnitCount;
+extern const char* coulombChargeUnits[];
+extern const int ampHourChargeUnitCount;
+extern const char* ampHourChargeUnits[];
+extern const double chargeToSIfactors[];
+extern const char** chargeUnits [];
+extern const int chargeUnitsCounts [];
+extern const unit charge;
+
+// Unknown unit.
+extern const int unknownUnitCount;
+extern const int unknownCount;
+extern const char* unknownunit [];
+extern const int unknownUnitsCount;
+extern const char** unknownUnits [];
+extern const int unknownUnitsCounts [];
+extern const double unknownUnitsFactors [];
+extern const unit unknownUnit;
+
+// Array of all units.
+extern const int unitsCount;
+extern const unit* unitps[]; // 7 SI base units: & then others.
+
+// Declarations of functions to show units (see SIunits.txt)
+extern void showAllUnits(const unit*, ostream&); // mass, length, time ...
+extern void showSIunit(const unit*, ostream&); //
+extern void showSIunits(const unit*, ostream&); // Show the SI unit & aliases.
+extern void showNonSIunits(const unit*, ostream&);
+ // Show just the base Non SI units, but not aliases.
+extern void showAllNonSIunits(const unit*, ostream&);
+ // Show all the Non SI units.
+
+unsigned int findUnit(const string, // multiple unit
+ const unit*, // unit
+ unsigned int&, // index of name, alias or abbrev given unit.
+ unsigned int&); // SIindex.
+
+const unit& findAnyUnit(const string, // multiple unit
+ unsigned int&, // index.
+ unsigned int&, // index of name, alias or abbrev given unit.
+ unsigned int&); // SIindex.
+
+#endif // SIUNITS_HPP

Added: sandbox/SOC/2007/quan/boost/quan/type_erasure_printer.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/type_erasure_printer.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,231 @@
+// Boost.TypeErasure decor printer
+//
+// Copyright 2011 Steven Watanabe
+// Copyright 2012 Paul A. Bristow
+//
+// Distributed under the Boost Software License Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// from \boost-sandbox\type_erasure\libs\type_erasure\example\print_sequence.cpp
+
+#ifndef BOOST_TYPE_ERASURE_PRINTER
+#define BOOST_TYPE_ERASURE_PRINTER
+
+#include <boost/type_erasure/any.hpp>
+#include <boost/type_erasure/iterator.hpp>
+#include <boost/type_erasure/operators.hpp>
+#include <boost/type_erasure/tuple.hpp>
+#include <boost/type_erasure/same_type.hpp>
+#include <boost/type_erasure/callable.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+
+#include<iostream>
+#include <iomanip>
+
+using namespace boost::type_erasure;
+
+// Placeholders used by the abstract printer during specification of requirements.
+struct _t : boost::type_erasure::placeholder {};
+struct _iter : boost::type_erasure::placeholder {};
+struct _os : boost::type_erasure::placeholder {};
+// This is more readable than using the 'out of the box' _a, ... _g placeholders.
+// See placeholder.hpp.
+
+template<class T, class U = _self>
+struct base_and_derived
+{ // Template parameter for concept_interface.
+ // and in list of requirements in abstract printer.
+ // base_and_derived<std::ios_base, _os>, // _os must derive from std::ios_base.
+ static T& apply(U& arg) { return arg; }
+};
+
+namespace boost {
+namespace type_erasure {
+
+template<class T, class U, class Base>
+struct concept_interface<base_and_derived<T, U>, Base, U> : Base
+{
+ operator typename rebind_any<Base, const T&>::type() const
+ {
+ return call(base_and_derived<T, U>(), const_cast<concept_interface&>(*this));
+ }
+ operator typename rebind_any<Base, T&>::type()
+ {
+ return call(base_and_derived<T, U>(), *this);
+ }
+};
+
+// Fully specialized for const std::pair<const int, double>&
+//std::ostream& operator<< (std::ostream& os, const std::pair<const int, double>& p)
+//{ /*! Output a pair of values.
+// \details For example: "1.23 , 3.45".
+// */
+// os << p.first << ", " << p.second;
+// return os;
+//} // std::ostream& operator<<
+
+// But more useful is just providing the two template version:
+
+template <typename T1, typename T2>
+std::ostream& operator<< (std::ostream& os, const std::pair<T1, T2>& p)
+{ /*! Output a pair of values with space as delimiter.
+ \details For example: "1.23 3.45".
+ */
+ os << p.first << " " << p.second;
+ return os;
+} // std::ostream& operator<< (std::ostream& os, const std::pair<T1, T2>& p)
+
+// Or can use a version defined elsewhere, for example, in namespace my_detail?
+
+// using my_detail::operator<<;
+
+// Partial specialization of struct ostreamable for pair<const int, double>:
+//template<class Os>
+//struct ostreamable<Os, std::pair<const int, double> >
+//{
+// static void apply(Os& out, const std::pair<const int, double>& arg)
+// {
+// out << arg;
+// }
+//};
+
+// Partial specialization of struct ostreamable for pair<T1, T2>:
+template<class Os, typename T1, typename T2>
+struct ostreamable<Os, std::pair<T1, T2> >
+{
+ static void apply(Os& out, const std::pair<T1, T2>& arg)
+ {
+ out << arg;
+ }
+};
+
+} // namespace type_erasure
+} // namespace boost
+
+/*! An abstract sequence printer - a 'template' that is inherited
+ to implement the examples of actual printers defined below.
+ */
+
+template< class CharT = char, class Traits = std::char_traits<char> >
+class abstract_printer
+{
+public:
+ //! \tparam Range must be a Forward Range whose elements can be printed to `ostream os`.
+ //! \param r Container to be printed, for example, a C array, std::vector, std::list ...
+ //! \param os `std::ostream` for printing, for example std::cout.
+
+ template<class Range, class CharT, class Traits>
+ void print(const Range& r, std::basic_ostream<CharT, Traits>& os = std::cout) const
+ {
+ // Capture the print arguments.
+ // Range iterators.
+ typename boost::range_iterator<const Range>::type
+ first(boost::begin(r)),
+ last(boost::end(r));
+ // Assemble requirements into tuple: range pair of iterators and ostream.
+ tuple<requirements, _iter, _iter, _os&> args(first, last, os);
+ // and forward to the real implementation.
+ do_print(get<0>(args), get<1>(args), get<2>(args));
+ // get<0>() is first, get<1>() is last, get<2>() is ostream.
+ }
+ virtual ~abstract_printer() {}
+protected:
+ // Define the requirements in an mpl::vector for containers to be printed.
+ typedef boost::mpl::vector<
+ base_and_derived<std::ios_base, _os>, // _os must derive from std::ios_base.
+ ostreamable<_os, _t>, // type _t must be ostreamable.
+ ostreamable<_os, const char*>, // C string must be ostreamable.
+ forward_iterator<_iter, const _t&>, // t range must have forward iterator.
+ same_type<_t, forward_iterator<_iter, const _t&>::value_type> // _t's type value and iterator must match.
+ > requirements;
+
+ // Use type_erasure::any to enforce the requirements onto ostream and iterator.
+ typedef boost::type_erasure::any<requirements, _os&> ostream_type;
+ typedef boost::type_erasure::any<requirements, _iter> iterator_type;
+ // Declare the pure virtual function `do_print` that is defined in all real printers.
+ virtual void do_print(iterator_type first, iterator_type last, ostream_type os) const = 0;
+}; // class abstract_printer
+
+/*!
+ Outputs items in a specified number of columns across rows with a separator (often comma and/or space(s)),
+ and a suffix (usually newline) every `num_column`s items.\n
+ Usage: `decor_printer simple_printer(3, 0, "\n", ", ", "\n", "\n");`\n
+ Provide a container to be printed: `double da[] = {1., 2., 3., 4., 5., 6.};`\n
+ Print to std::cout using: `simple_printer.print(std::cout, da);` \n
+ Output:\n
+ 1, 2, 3,\n
+ 4, 5, 6,\n
+ 7, 8, 9,\n
+ 10, 11, 12\n
+ The order of parameters is chosen to try to allow use of the defaults as much as possible,
+ including all defaults placing all items on one line or row separated by spaces.
+
+ \param num_columns number of columns (default 0, so all items are on the same line or row).
+ \param width ostream width to use to each items (default 0 so that columns may be jagged).
+ \param pre string to be output before the first column,
+ (default newline which ensures that the first item is at the left margin).
+ \param sep string to separate (or delimit) items on each row (default space).
+ \param suf suffix at the end of each row (default newline).
+ \param term string to terminate the last row
+*/
+class decor_printer : public abstract_printer<>
+{
+public:
+ explicit decor_printer(
+ std::size_t num_columns = 0,
+ std::size_t wid = 0,
+ const std::string& pre = "\n",
+ const std::string& sep = " ",
+ const std::string& suf = "\n",
+ const std::string& term = "\n")
+ :
+ cols(num_columns), width(wid), prefix(pre), separator(sep), terminator(term), suffix(suf)
+ { /*! Constructor.\n
+ Usage: for example: ``3, 10, "double testd[] = {\n ", ", ", "\n ", "\n };\n"``
+ 3 columns with width 10, prefix "double testd[] = {\n ", separator string comma space,
+ suffix (newline at the end of a column),
+ and a terminator string "\n };\n".\n
+ Defaults are provided for all parameters, so can contruct: `my_default_printer decor_printer;`\n
+ that places all items on one line or row with space between items, and a final newline.
+ */
+ }
+protected:
+ // Print all items in rows.
+ virtual void do_print(iterator_type first, iterator_type last, ostream_type os) const
+ {
+ os << prefix.c_str();
+ std::size_t count = 0;
+ for(; first != last; ++first)
+ {
+ if (width > 0)
+ {
+ static_cast<std::ios_base&>(os).width(width);
+ }
+ os << *first;
+ boost::type_erasure::any<requirements, _iter> temp = first;
+ ++temp;
+ if(temp != last)
+ {
+ os << separator.c_str();
+ }
+ ++count;
+ if((cols != 0) && (count % cols == 0))
+ { // Last column.
+ os << suffix.c_str(); // Usually newline at end of a row.
+ }
+ }
+ os << terminator.c_str(); // Perhaps useful to have a terminating newline?
+ }
+private:
+ std::size_t cols; // Set by constructor, number of columns (default 10).
+ std::size_t width; // Set by constructor, optional column width (default zero).
+ std::string prefix; // Set by constructor, for example, "{ ".
+ std::string separator; // Set by constructor, for example, ", ".
+ std::string suffix; // Set by constructor, for example "\n".
+ std::string terminator; // Set by constructor, for example, "}\n".
+}; // class decor_column_printer
+
+#endif // ifndef BOOST_TYPE_ERASURE_PRINTER

Added: sandbox/SOC/2007/quan/boost/quan/unc.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/unc.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,2114 @@
+/*! \file
+ \brief Class for simple Propagation of Uncertainties according to a pure Gaussian model.
+
+ \details Based on code by Evan Manning (manning_at_[hidden])
+ Evan Marshal Manning, C/C++ Users Journal, March 1996 page 29 to 38.
+ original downloaded from ftp://beowulf.jpl.nasa.gov/pub/manning
+ This is a simple model of uncertainties, designed to
+ accompany an article published in C/C++ Users Journal March 1996
+ at http://www.ddj.com/cpp/184403147 .
+ A fuller collection of even fancier classes also given in unc.h.
+
+ Standard deviation & its uncertainty added Paul A Bristow 31 Mar 98 to May 2012.
+
+ \mainpage
+ \n
+ \b Boost.Quan
+
+This is the standalone Doxygen main page of the proposed Boost.Quan library.
+
+This library provides a collection of classes and functions for handling uncertain reals.
+
+Uncertainty as standard deviation and degrees of freedom are
+propagated through calculations using the uncertain type,
+and are input and output including the uncertainty estimates.
+
+See Boost.Quan HTML Manual at
+
+ https://svn.boost.org/svn/boost/sandbox/quan/libs/quan/doc/html/index.html
+
+and/or equivalent PDF Manual at:
+
+ https://svn.boost.org/svn/boost/sandbox/quan/libs/quan/doc/quan.pdf
+
+Examples are in folder:
+
+ https://svn.boost.org/svn/boost/sandbox/quan/libs/quan/example/
+
+and C++ include files are in folder:
+
+ https://svn.boost.org/svn/boost/sandbox/quan/boost/quan/
+
+*/
+
+// unc.hpp
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Copyright Paul A. Bristow 1998, 2012.
+
+#ifndef UNC_HPP
+#define UNC_HPP
+
+#ifdef _MSC_VER
+# pragma once
+# pragma warning (disable : 4127) // conditional expression is constant.
+# pragma warning (disable : 4800)// forcing value to bool 'true' or 'false' (performance warning).
+# pragma warning (disable : 4189) // local variable is initialized but not referenced.
+// Could use no_unused_variable_warning(x);
+//template<class T> // Avoid MSVC warning "C4189 variable initialised but not used".
+//inline void no_unused_variable_warning(const T&) {}
+#endif// _MSC_VER
+
+#include <boost/math/special_functions/fpclassify.hpp>
+ //using boost::math::isnan;
+ //using boost::math::isinf;
+ //using boost::math::isfinite;
+ //using boost::math::isnormal; // isfinite and not denormalised.
+// Might instead use the std TR1 versions?
+
+#include <cstdlib> //
+#include <cmath> // for log, exp etc
+#include <iostream> //
+ //using std::istream;
+ //using std::ostream;
+ //using std::ios_base;
+ //using std::char_traits;
+ //using std::cout;
+ //using std::cerr;
+ //using std::cin;
+ //using std::endl;
+ //using std::flush;
+ //using std::ws;
+ //using std::streamsize;
+ //using std::boolalpha;
+ //using std::dec;
+ //using std::hex;
+ //using std::showbase;
+ //using std::fixed;
+ //using std::scientific;
+ //using std::right;
+ //using std::showpos;
+ //using std::noshowpos;
+ //using std::noshowbase;
+ //using std::noshowpoint;
+ //using std::showpoint;
+
+#include <iomanip> //
+ //using std::setprecision;
+ //using std::setw;
+ //using std::resetiosflags;
+#include <algorithm>
+ //using std::max;
+ //using std::min;
+
+#include <sstream> //
+ // using std::ostringstream;
+#include <limits> // for numeric_limits<unsigned short>::max() etc
+// using std::numeric_limits;
+//#include <locale> // for . or , for decimal point
+#include <exception> //
+ //using std::exception;
+ //using std::bad_alloc;
+
+#include <boost/quan/xiostream.hpp> // for extra manipulators, spaces.
+// These extra manipulators have been placed in std for convenience.
+ //using std::noadjust; // Restore to default state.
+ //using std::nofixed; // Restore to default state.
+ //using std::noscientific; // Restore to default state.
+ //using std::defaultfloat; // Restore fixed & scientific to default state.
+ //using std::hexbase;
+ //using std::lowercase;
+
+#include <boost/quan/unc_init.hpp> // Defines indexes to xalloc iword(index) variables.
+#include <boost/quan/rounding.hpp> // Rounding functions.
+#include <boost/lexical_cast.hpp>
+
+#include <boost/static_assert.hpp>
+BOOST_STATIC_ASSERT (std::numeric_limits<double>::is_iec559); // Assume IEEE 754 ONLY.
+// == _STATIC_ASSERT (numeric_limits<double>::is_iec559); // and MS STATIC assert.
+
+#include <boost/io/ios_state.hpp>
+#include <boost/units/io.hpp>
+#include <boost/units/static_rational.hpp>
+#include <boost/type_traits.hpp>
+
+void outIosFlags(long, std::ostream&); // Output ios flags.
+void outUncTypes(unsigned short int, std::ostream&);
+
+//namespace boost {
+//namespace units {
+
+// Forward declarations.
+template <bool is_correlated> // Default is uncertainties that are NOT correlated.
+class unc;
+
+// Two actual uncertain floating-point types for the user:
+
+typedef unc<false> uncun; //! Uncertainties are NOT correlated.
+//! Uncorrelated is the normal case when uncertainties add.
+
+typedef unc<true> unccorr; //! Uncertainties ARE correlated.
+//! This is the unusual case where the sum must be exact,
+//! so the uncertainties are subtracted.
+//! Example: two blocks which fit into a box perfectly.
+//! So if both have an uncertainties, they must cancel when the uncertainties are added.
+//! Also applies to items like concentrations which must add up to 100% or unity.
+
+// Obselete - now implemented directly as operator <<
+//void unc_output(double value, // Mean or most likely value.
+// float stdDev, // Standard deviation.
+// unsigned short int degFree, // Degrees of freedom.
+// unsigned short int uncTypes, // 16 Uncertain type flags.
+// ostream& os); // Output stream, default std::cout.
+
+
+void unc_input(double& mean, // mean (central or most probable) value.
+ double& stdDev,
+ unsigned short int& degreesOfFreedom, // 1 observation.
+ unsigned short int& uncTypes,
+ std::istream& is);
+
+//template<typename correlated> std::ostream& operator<< (std::ostream& os, const unc<false>& u);
+//template<typename correlated> std::ostream& operator<< (std::ostream& os, const unc<false>& u);
+// Need to declare so that can make a friend (in unc), and thus access private data value_ etc.
+// See http://www.parashift.com/c++-faq-lite/templates.html#faq-35.16
+// This avoids failure to instantiate these operators, and thus link failures.
+// May need for input operator>> too.
+// template<typename correlated> std::istream& operator>> (std::istream& is, const unc<false>& u);
+// friend istream& operator>> (istream& is, UReal<correlated>& u)
+
+template <typename Type> inline Type sqr(const Type& a);
+template <typename Type> inline Type cube(const Type& a);
+template <typename Type> inline Type pow4(const Type& a);
+
+// These should be defined elsewhere, but will not compile.
+//! Quaded function, notationally convenient for x^4, but overflow possible?
+//! Used by Welch-Satterthwaite formula.
+template <typename Type>
+inline Type pow4(const Type& a)
+{
+ return (Type)(a * a * a * a);
+}
+
+template <typename Type> inline Type sqrtSumSqrs (const Type& a, const Type& b);
+template <typename Type>
+inline Type sqrtSumSqrs (const Type& a, const Type& b)
+{
+ return (Type)sqrt(a * a + b * b);
+}
+
+// SI units from CRC Handbook of Chemistry & Physics 76th edition 1995,
+// ISBN 08493 0476-8 page 1-22.
+
+// SI Usage, ISO 30-0 to 30-13:1992 is 'International Consensus Document'.
+
+// ANSI/IEEE Std 268-1992 Americal National Standard for Metric Practice,
+// (adopted for US Department of Defence)
+
+// ASTM E 380-93 now consolidated with ANSI 268.
+
+// NIST Special Publication 811, Barry N Taylor
+// Guide for the Use of the International System of Units 1995
+// which was derived from IEEE Std 268, IEEE Standard Metric Practice (1982)
+
+// Most useful commentary on the these standards, and annotated bibliography.
+// (available from www.physics.NIST.gov)
+
+// ISO 2955 = BS 6430 :1983 (1988)
+// Method for representing SI and other units in information processing
+// system with limited character sets.
+
+// Gives two sets of representation, for SI units and other ISO 1000 units,
+// for use in data interchange by systems with limited graphic character sets.
+// Mainly important for allowing u instead of greek mu.
+
+// Gunther Schadow & Clement J. McDonald,
+// The Unified Code for Units of Measure,
+// A critique and proposals of ISO and ANSI, and ENV 12435
+// http://aurora.rg.iupui.edu/~schadow/units/UCUM/ucum.html
+
+void outUncValues(std::ostream& os, std::ostream& log); // Output uncertain values.
+void setUncDefaults(std::ios_base& os); // Set I=Unc class defaults for stream os.
+
+ //! 16 type bits used by unc uncTypes. Bit set = 1 means a positive attribute.
+enum unc_types
+{
+ VALUE_ZERO = 1 << 0, //!< bit zero = 1 means value is zero.
+ //! (Too near zero to allow relsd = sd /mean.)
+ //! A few times std::numeric_limits<float>::min() may be a suitable limit?
+ VALUE_INTEGER = 1 << 1, //!< Exact integer 2,3,4 ... may not be possible to store `int` into `double`?
+ VALUE_RATIONAL = 1 << 2, /*!< Integers & Fractions 1/2, 1/3, 2/3, 5/4 ...
+ so don't need irrational - must be if not rational.
+ Irrational like pi, e ... represented as accurately as possible by the double floating-point type,
+ usually for 64-bit double, 15 to 17 decimal digits.
+ */
+ VALUE_NEGATIVE_ONLY = 1 << 3, //!< Value can ONLY be < 0.. ? or <=0?
+ VALUE_POSITIVE_ONLY = 1 << 4, //!< Value can ONLY be >=0..
+ UNC_KNOWN = 1 << 5, //!< Uncertainty known (but if not, value may still be known OK).
+ UNC_NOPLUS = 1 << 6, //!< Uncertainty can only be < value, + = zero.
+ UNC_NOMINUS = 1 << 7, /*!< Uncertainty can only be > value - = zero.
+ Integer, Rational or Exact by definition like 25.4 mm per inch,
+ if unc = 0.0f or both UNC_NOPLUS & UNC_NOMINUS.
+ */
+ UNC_QUAN_DECIMAL = 1 << 8, //!< Quantised by least significant decimal digit.
+ UNC_QUAN_BINARY = 1 << 9, //!< Quantised by least significant binary digit.
+ UNC_EXPLICIT = 1 << 10, /*!< If bit set = 1, uncertainty implicit from read significant digits,
+ for example: unc_input of 10.0 will set this bit and set uncertainty = 0.05,
+ or explicit if +/- or calculated (normal default case, bit = 0).
+ */
+ UNC_UNIFORM = 1 << 11, //!< Uncertainty has rectangular or uniform probability distribution.
+ UNC_TRIANGULAR = 1 << 12, //!< Uncertainty has triangular probability distribution.
+ //! If not rectangular or triangular bits set, then normal or Gaussian distribution, the default.
+ //! Both bits 11 and 12 == 1 then has distribution un-defined as yet.
+ //! Distribution type is used to estimate confidence intervals and rounding.
+ DEG_FREE_EXACT = 1 << 13, //!< Known number of observations -1,
+ //! so default zero means 1 observation.
+ //! else estimated, for example, using Welch-Satterthwaite.
+ DEG_FREE_KNOWN = 1 << 14, //!< Degrees of freedom is defined.
+ SPARE = 1 << 15 //!< This last unc_type is spare.
+}; // enum unc_types
+
+const unsigned short int VALUE_EXACT = (UNC_NOMINUS | UNC_NOPLUS); //!< Both set.
+const unsigned short int UNC_DEF = (UNC_KNOWN | UNC_NOMINUS | UNC_NOPLUS | //!< Any defined means that uncertainty is defined.
+ UNC_QUAN_DECIMAL | UNC_QUAN_BINARY |
+ UNC_EXPLICIT //!< Not implicit from number of significant digits.
+ | UNC_UNIFORM | UNC_TRIANGULAR); //
+const unsigned short int DEG_FREE_DEF = (DEG_FREE_EXACT | DEG_FREE_KNOWN);
+
+extern const char* uncTypeWords[];
+
+enum uncertainflags
+{ //! \enum uncertainflags Control of printing uncertain values, similar to ios flags.
+ defaults = 0, //!< Default.
+ firm = 1 << 0, //!< bit 0: == 0 == false means flex, or firm == 1 == true.
+ setScaled = 1 << 1, //!< bit 1 Set scaled == 1 or not scaled == 0.
+ //! by fixed factor SetScale and << scale ...
+ //! power10 in range -max to +max.
+ autoScaled = 1 << 2, //!< bit 2: auto = 1 with << autoscale ...
+ plusMinus = 1 << 3, /*!< bit 3 = 1 means add +/- uncertainty
+ Usage: `std::cout << plusminus << u;`
+ */
+ addSISymbol = 1 << 4, //!< bit 4 = 1, add suffix SI symbol G, M, k, m, u, n, p ...
+ //! If one is applicable, else = 0 do nothing.
+ addSIPrefix = 1 << 5, //!< bit 5 = 1, add suffix SI prefix Giga, Mega, kilo ...
+ noisyDigit = 1 << 6, /*!< Add extra 'noisy' decimal digit to value & sd.
+ Usage: std::cout `<< addnoisyDigit << u;`
+ This means is suitable for input to other calculations because the
+ random extra 2 to 3 bits will approximate a continuous function.
+ Quantization to fewer digits would distort statistical calculations.
+ Default is to use minimum decimal digits for clearer display.
+ Extra digit also added when degrees of freedom > 10.
+ */
+ useSetSigDigits = 1 << 7, //!< if bit 7 = 1 use set sig digits else calculate from sd(isUseSetSigDigits).
+ useSetUncSigDigits = 1 << 8, //!< if bit 8 = 1 use set Unc sigfig (isStdDevSigDigitsSet).
+ //! else calculate from degrees of freedom.
+ degfree = 1 << 9, //!< 0x200, If bit 9 == 1, add output of degrees of freedom as (99).
+ // Usage: std::cout `<< adddegfree << u;`
+ replicates = 1 << 0xA, //!< 0x400 If == 1, add output of replicates as [99] if > 1.
+ limits = 1 << 0xB, //!< 0X800 add limits.
+ // 0xC, D, E and F spare - and iword is actually a long so could use 32 flags.
+}; // enum uncertainflags
+
+void outFpClass(double, std::ostream&); // Special output for inf, NaN...
+
+// Declarations of parameterless Manipulators,
+// similar to ios_base flags but for uncertain printing.
+// Use upperand lower case convention for these,
+// but all lowercase for manipulators like hex, oct ...
+// Usage: out << scale << noscale << autoscale << noautoscale
+// firmform << flexform << plusminus << noplusminus ....
+
+//! All ios_base functions declared below are defined in unc.ipp
+//! \note that all of these are entirely lower case names, like std::ios manipulators.
+
+std::ios_base& scale(std::ios_base&); //!< To use value set with setScale(int)
+std::ios_base& noscale(std::ios_base&); //!< or not scale.
+std::ios_base& autoscale(std::ios_base&); //!< Automatically Scale to suitable prefix symbol like M, k, m...
+std::ios_base& noautoscale(std::ios_base&); // or not to scale to prefix symbol.
+std::ios_base& firmform(std::ios_base&); //!< Firm fixed layout using setUncWidth.
+std::ios_base& flexform(std::ios_base&); //!< Flexible free format.
+std::ios_base& plusminus(std::ios_base&); //!< Add +/- uncertainty.
+std::ios_base& noplusminus(std::ios_base&); //!< Do not add +/- uncertainty
+std::ios_base& addsiprefix(std::ios_base&); //!< Add SI prefix like kilo, micro ..
+std::ios_base& nosiprefix(std::ios_base&); //!< (Takes precedence over SI symbol if both set).
+std::ios_base& addsisymbol(std::ios_base&); //!< Add SI symbol like M, k, m.
+std::ios_base& nosisymbol(std::ios_base&); //!< Do not add SI symbol like M, k, m.
+std::ios_base& addnoisyDigit(std::ios_base&); //!< Add an extra 'noisy' digit for less risk of loss.
+std::ios_base& nonoisyDigit(std::ios_base&); //!< No noisy to suit human reading.
+std::ios_base& autosigdigits(std::ios_base&); //!< Calculate sigdigits from uncertainty (default).
+std::ios_base& setsigdigits(std::ios_base&); //!< Use sig digits stored with `<< setSigDigits(6)` for value.
+std::ios_base& autouncsigdigits(std::ios_base&); //!< Calculate stdDev sig digits from uncertainty.
+std::ios_base& uncsigdigits(std::ios_base&); //!< Use stdDev sigDigits stored with << useSetUncSigDigits(2) ...
+std::ios_base& adddegfree(std::ios_base&); //!< Add degrees of freedom as (99).
+std::ios_base& nodegfree(std::ios_base&); //!< Do not add degrees of freedom to output of value.
+//
+std::ios_base& addlimits(std::ios_base&); //!< Add lower and upper limits a 0.95 > 1.00 > 1.05.
+std::ios_base& nolimits(std::ios_base&); //!< Do not add lower and upper limits.
+
+// Obselete
+//std::ios_base& confidence(std::ios_base&);
+/*!< Use stdDev sigDigits stored with `<< setconfidence( 0.01) ...`
+ or alpha to control estimation of confidence interval. 0.01 means 99% confidence.
+ */
+//std::ios_base& roundingloss(std::ios_base&); //!< Set the acceptable loss from rounding.
+//std::ios_base& addreplicates(std::ios_base&); //!< Add degrees of replicates > 1 as [99].
+//std::ios_base& noreplicates(std::ios_base&); //!< Do not add degrees of freedom or replicates >1.
+
+/*! Functions to change uncertain flags on specified ios_base.
+ Usage: \code f = uFlags(out); f = uFlags(out, 0xFF);
+ f = setuFlags(out, 0xFF); f = resetuFlags(out, 0xFF);
+ \endcode
+*/
+long uFlags(std::ios_base&); //!< Returns current uncertain flags.
+long uFlags(std::ios_base&, long); //!< Assigns all uncertain flags & returns previous.
+long setuFlags(std::ios_base&, long); //!< Set specific flags = 1
+long resetuFlags(std::ios_base&, long); //!< Reset/clear specific flags = 0
+
+// Forward declarations, defined in unc.ipp.
+class showUncFlags; //!< Output uncertain flags to `ostream << showUncFlags `.
+class setAllUncFlags; //!< Assign value to set (and/or clear) all unc flags.
+class setUncFlags; //!< Set specific unc flags bits.
+class setMaskedUncFlags; //!< Clear mask & then set unc flag bits.
+class resetUncFlags; //!< Reset all unc flags bits.
+class resetMaskedUncFlags; //!< Reset specific unc flags bits.
+class setUncWidth; //!< Set width of uncertainty output.
+class setScale; //!< Set scaling factor like 1e3, 1e6 ... `<< setScale(6)`.
+class setSigDigits; //!< sigdigits to use for value if `<< setsigdigits(4)`.
+class setUncSigDigits; //!< sigdigits to use for uncertainty if `<< setuncsigdigits(1)`.
+class setRoundingLoss; //!< Set acceptable loss due to rounding.
+class setConfidence; //!< Set acceptable loss due to rounding.
+
+// Operator declarations, classes defined below, with constructors in unc.ipp.
+std::ostream operator<< (std::ostream, const showUncFlags&);
+std::ostream operator<< (std::ostream, const setAllUncFlags&);
+std::istream operator>> (std::istream, const setAllUncFlags&);
+std::ostream operator<< (std::ostream, const setUncFlags&);
+std::istream operator>> (std::istream, const setUncFlags&);
+std::ostream operator<< (std::ostream, const setMaskedUncFlags&);
+std::istream operator>> (std::istream, const setMaskedUncFlags&);
+std::ostream operator<< (std::ostream, const resetUncFlags&);
+std::istream operator>> (std::istream, const resetUncFlags&);
+std::ostream operator<< (std::ostream, const resetMaskedUncFlags&);
+std::istream operator>> (std::istream, const resetMaskedUncFlags&);
+std::ostream operator<< (std::ostream, const setUncWidth&);
+std::istream operator>> (std::istream, const setUncWidth&);
+std::ostream operator<< (std::ostream, const setScale&);
+std::istream operator>> (std::istream, const setScale&);
+std::ostream operator<< (std::ostream, const setUncSigDigits&);
+std::istream operator>> (std::istream, const setUncSigDigits&);
+std::ostream operator<< (std::ostream, const setRoundingLoss&);
+std::ostream operator<< (std::ostream, const setConfidence&);
+std::ostream operator<< (std::ostream, const setSigDigits&);
+std::istream operator>> (std::istream, const setSigDigits&);
+
+void outUncFlags(long uncflags, std::ostream);
+
+class showUncFlags
+{ // Constructor & operator<< defined in unc.ipp
+ friend std::ostream operator<< (std::ostream, const showUncFlags&);
+public:
+ showUncFlags(unsigned short int); // Definition in unc.ipp.
+ unsigned short int flags;
+};
+
+class showUncTypes
+{ // Constructor & operator<< defined in unc.ipp
+ // Usage: out << showUncTypes(unc) ...
+ friend std::ostream operator << (std::ostream, const showUncTypes&);
+public:
+ showUncTypes(unsigned short int); // Definition in unc.ipp.
+ unsigned short int types;
+};
+
+// setAllUncflags(int flags, int mask);
+// Usage: out << setAllUncFlags(0x5a) ...
+class setAllUncFlags // Set ALL uncertain flags (not just OR selected bits).
+{
+ friend std::ostream operator<< (std::ostream, const setAllUncFlags&);
+ friend std::istream operator>> (std::istream, const setAllUncFlags&);
+public:
+ setAllUncFlags(int); // w) : flags(w) {} // Constructor initialisation flags = w.
+ int flags; // setAllUncFlags.flags used by operators << and >>
+};
+
+class setUncFlags // Set selected uncertain flags.
+{// Usage: out << setUncFlags(0xFFFF, 0x7, 0x3) ...
+ // or setUncFlags(out, 0x7);
+
+ friend std::ostream operator<< (std::ostream, const setUncFlags&);
+ friend std::istream operator>> (std::istream, const setUncFlags&);
+public:
+ setUncFlags(int); // Constructor initialisation flags.
+ int flags; // setUncFlags.flags used by operators << and >>
+};
+
+// setMaskedUncflags(int flags, int mask);
+// Usage: out << setMaskedUncFlags(0xFFFF, 0x7, 0x3) ...
+// or setUncFlags(out, 0x7);
+class setMaskedUncFlags
+{
+ friend std::ostream operator<< (std::ostream, const setMaskedUncFlags&);
+ friend std::istream operator>> (std::istream, const setMaskedUncFlags&);
+public:
+ setMaskedUncFlags(int, int); // : flags(w), mask(m) {} // Constructor initialisation flags = w.
+ int flags; // setMaskedUncFlags.flags used by operators << and >>
+ int mask; // Selected bits to deal with by zeroing before setting flags.
+};
+
+class resetUncFlags // Reset = 0 selected uncertain flags.
+{// Usage: out << resetUncFlags(0xFFFF, 0x7, 0x3) ...
+ // or setUncFlags(out, 0x7);
+
+ friend std::ostream operator<< (std::ostream, const resetUncFlags&); // Declarations
+ friend std::istream operator>> (std::istream, const resetUncFlags&);
+public:
+ resetUncFlags(int);// w) : flags(w) {} // Constructor initialisation flags = w.
+ int flags; // setUncFlags.flags used by operators << and >>
+};
+
+// setMaskedUncflags(int flags, int mask);
+// Usage: out << resetMaskedUncFlags(0xFFFF, 0x7, 0x3) ...
+// or setUncFlags(out, 0x7);
+class resetMaskedUncFlags
+{
+ friend std::ostream operator<< (std::ostream, const resetMaskedUncFlags&);
+ friend std::istream operator>> (std::istream, const resetMaskedUncFlags&);
+public:
+ resetMaskedUncFlags(int, int); // : flags(w), mask(m) {} // Constructor initialisation flags = w.
+ int flags; // setMaskedUncFlags.flags used by operators << and >>
+ int mask; // Selected bits to deal with by zeroing before setting flags.
+};
+
+class setUncWidth // Set uncertain width.
+{
+ friend std::ostream operator<< (std::ostream, const setUncWidth&); // Declarations
+ friend std::istream operator>> (std::istream, const setUncWidth&); // Defined below.
+ // Allows ostream operator>> and << to access private member width.
+public:
+ setUncWidth(int);
+ int uncWidth; // setUncWidth used by operators << and >>
+};
+
+// setScale(int scale);
+// Usage: out << setScale(6) // == 10**6) ...
+class setScale // Set uncertain scale.
+{
+ friend std::ostream operator<< (std::ostream, const setScale&); // Declarations
+ friend std::istream operator>> (std::istream, const setScale&); // Defined below.
+ // Allows ostream operator>> and << to access private member scale.
+public:
+ setScale(int); // n) : scale(n) {} // Constructor - initialisation scale = n.
+ int scale; // setScale.scale used by operators << and >>
+};
+
+// Usage via class: setSigDigits(int sigDigits);
+// Usage via operator << : out << setSigDigits(6) ...
+class setSigDigits
+{
+ friend std::ostream operator<< (std::ostream, const setSigDigits&); // Declarations
+ friend std::istream operator>> (std::istream, const setSigDigits&);
+public:
+ setSigDigits(int);// w) : sigDigits(w) {} // Constructor in unc.ipp
+ // Initialisation means sigDigits = w.
+ int sigDigits_; // setSigDigits.flags used by operators << and >>
+};
+
+/*! setUncSigDigits(int uncSigDigits);
+ Permits choice of number of uncertain or stddev value:\n
+ 2 is the ISO recommendation.\n
+ Uncertainty of measurement -- Part 3: Guide to the expression of uncertainty in measurement (GUM:1995)\n
+ ISO Guide 98 (1995) and updated version 2008.\n
+ 1 is more appropriate for very small degrees of freedom,
+ (but it gives a big step when the value starts with 1 or 2,
+ when the difference between 1.4 (rounded to 1) and 1.6 (rounded to 2.) is a doubling.
+ 3 is appropriate only for large degrees of freedoms, >= 1000.
+ \warning Values < 1 or > 3 are silently ignored.
+ -1 passes through to allow dymanic choice based on degress of freedom.
+ Usage: out << setUncSigDigits(3) ...
+*/
+class setUncSigDigits
+{
+ friend std::ostream operator<< (std::ostream, const setUncSigDigits&); // Declarations
+ friend std::istream operator>> (std::istream, const setUncSigDigits&);
+public:
+ setUncSigDigits(int);// w) : uncSigDigits(w) {} // Constructor
+ // Initialisation means uncSigDigits = w.
+ //protected:
+ int uncSigDigits_; // Set by constructor.
+}; // class setUncSigDigits
+
+//! setRoundingLoss(int setRoundingLoss); to control the acceptable rounding loss.
+//! Usage: `out << setRoundingLoss(0.01)` ...
+
+class setRoundingLoss
+{
+ friend std::ostream operator<< (std::ostream, const setRoundingLoss&); // Declarations
+ friend std::istream operator>> (std::istream, const setRoundingLoss&);
+public:
+ setRoundingLoss(double);// eps) : setRoundingLoss(eps) {} // Constructor
+ // Initialisation means setRoundingLoss = epsilon
+ //protected:
+ double roundingloss_; // Set by constructor.
+}; // class setRoundingLoss
+
+//! setConfidence(int setConfidence); to control the confidence interval.
+//! Usage: `out << setConfidence(0.01)` ...
+
+class setConfidence
+{
+ friend std::ostream operator<< (std::ostream, const setConfidence&); // Declarations
+ friend std::istream operator>> (std::istream, const setConfidence&);
+public:
+ setConfidence(double);// alpha) : setConfidence(alpha) {} // Constructor
+ // Initialisation means setConfidence = alpha
+ //protected:
+ double confidence_; // Set by constructor.
+}; // class setConfidence
+
+
+/*! Uncertain number template class unc,
+ using mean and uncertainty (equivalent to std deviation if pure Gaussian),
+ but also includes information about uncertainty as degrees of freedom & distribution.
+*/
+template <bool is_correlated = false> //! \tparam is_correlated if true, standard deviation is correlated, else not.
+class unc : public std::char_traits<char>
+{
+ typedef double value_type;
+
+
+ friend void unc_input(double& mean, // Mean (central or most probable) value.
+ double& stdDev, // Uncertainty estimate as Standard deviation.
+ unsigned short int& degreesOfFreedom, // Degrees of freedome -1. (Default zero for 1 observation).
+ unsigned short int& types, // 16 Uncertain type flags showing type of value.
+ std::istream& is);
+ //friend void unc_output(double value, // Mean(central or most probable) value.
+ // float stdDev, // Uncertainty estimate as Standard deviation.
+ // unsigned short int degFree, // Degrees of freedom.
+ // unsigned short int uncTypes, // 16 Uncertain type flagsshowing type of value.
+ // std::ostream& os); // Output stream, default std::cout.
+
+ // using char_traits<char>::int_type; // Derivation from public \c std::char_traits<char> needed for \c int_type.
+
+//#pragma warning (disable : 4520) //!< 'unc<1>' : multiple default constructors specified.
+ // This is by design so that it is possible construct from integer or double.
+ // Doubtful if this is necessary or useful?
+public:
+ /*! \note It is convenient to use 64-bit floating-point value
+ (so even really accurate values like weights are OK),
+ 32-bit floating-point is ample accuracy for standard deviation fractional variation,
+ leaving two 16-bit for degrees of freedom and other flags,
+ so that total is same as two doubles & can be efficiently aligned.
+ */
+ double value_; //!< aka mean, estimate, or most likely value.
+ float uncertainty_; //!< Standard deviation, if known.
+ //! Reduced precision (float guarantees 6 decimal digits not 15) and range e38 not E304
+ //! should not be a problem unless value is (near) less than 1e38.
+ //! Can be zero, meaning exact, and can be negative or anti-correlated,
+ //! for example when values must add up to a total like 100%.
+ //! Relative (Fraction) Coefficent of variation =
+ //! Standard deviation / value (aka % +|- /100)
+ //! Relative is a problem if value near zero.
+ //! +|- is std deviation, so
+ //! for input of "1.0" implicit standard deviation and uncertainty limits +|- 0.05.
+ short unsigned int degFree_; /*!< degrees of freedom, usually = number of observations;
+ so for 2 observations assign 1 to degFree_ degree of freedom.
+ Range from 1 (usally 1 observation) to 65534 = std::numeric_limits<unsigned short int>::max() - 1
+ Higher numbers of observations are indistinguishable from infinite observations.
+ Max unsigned value 0xFFFF == 65535 is used to indicate degFree_ is NOT meaningful.
+ Zero is as yet undefined?
+ BUT many programs seem to use NON-integer degrees of freedom,
+ so a float might seem better, but is 32 bits not 16, so use 16 for compact struct.
+ (Might use an explicit 16 bit unsigned integer type?)
+ */
+ short unsigned int unctypes_; //!< Information about the value and uncertainty,
+ //! encoded as a bitmap 16 bits, 0 to 15 See enum unc_types,
+
+ //! \note These sizes mean that total size of a unc is 64 = 32 + 32 = 128 bits
+ // for IEEE-754 systems with 64-bit double.
+public:
+ // Member functions to get & value, stdDev, degfree & uncTypes.
+ //! \return Central estimate of value of uncertain type.
+ double value()
+ {
+ return value_;
+ }
+ //! \return Estimate of uncertainty as standard deviation of value of uncertain type.
+ float std_dev()
+ {
+ return uncertainty_;
+ }
+ //! \return Estimate of number of degrees of freedom, usually = number of observations -1.
+ unsigned short int deg_free()
+ {
+ return degFree_;
+ }
+ //! \return Types of uncertain real, encoded as a bitmap.
+ unsigned short int types()
+ {
+ return unctypes_;
+ }
+
+ // Set functions.
+ //! \param value Central estimate of value of uncertain type.
+ void value (double value)
+ {
+ value_ = value;
+ } // void setValue (double value)
+
+ //! \param unc Estimate of uncertainty as standard deviation of value of uncertain type.
+ void std_dev (float unc)
+ {
+ uncertainty_ = unc;
+ if (boost::math::isfinite(static_cast<double>(unc)))
+ {
+ unctypes_ |= UNC_KNOWN; // set unc is known
+ if (unc > 0.f)
+ { // NOT exact.
+ unctypes_ &= ~(VALUE_EXACT | VALUE_RATIONAL | VALUE_INTEGER | UNC_NOPLUS | UNC_NOMINUS); // Clear.
+ }
+ else
+ { // Exact.
+ unctypes_ |= (VALUE_EXACT | UNC_NOPLUS | UNC_NOMINUS); // Set
+ }
+ }
+ else
+ { // unc not finite!
+ unctypes_ &= ~UNC_KNOWN; // Clear as unc not known.
+
+ }
+ } // void std_dev (float unc)
+
+ //! \param df Number of degrees of degrees of freedom, usually = number of observations -1.
+ void deg_free (short unsigned int df)
+ {
+ degFree_ = df;
+ unctypes_ |= DEG_FREE_KNOWN; // set.
+ } // void deg_free (short unsigned int df)
+
+ // TODO rename these.
+ //! \param type bits indicating type of uncertain real.
+ void setUncTypes (short unsigned int type)
+ {
+ unctypes_ = type;
+ } // Set all type flag(s).
+
+ void types (short unsigned int type)
+ {
+ unctypes_ &= ~type;
+ } // Clear type flag(s).
+
+ // Constructors.
+
+ /*! Default constructor from double value & float uncertainty.
+ Constructor from just a double value assumed exact,
+ so behaves like a normal double.
+ Normal conversion from double to unc.
+ (See also constructor from integer which alone sets integer flag.)
+ */
+ unc(
+ // Default values: exact zero? with no uncertainty, 1 observation.
+ const double val, // = 0., // also const int = 0.
+ // Ignore warning C4520: 'unc<1>' : multiple default constructors specified
+ // (because they will be the same default values).
+ const float unc = 0.0f, // Default value exact.
+ const short unsigned int df = 1, // df means observations = 1.
+ const short unsigned int uncTypeFlags = UNC_KNOWN | UNC_EXPLICIT| DEG_FREE_EXACT | DEG_FREE_KNOWN) // unc type flags.
+ : value_(val), uncertainty_(unc), degFree_(df), unctypes_(uncTypeFlags)
+ {
+#ifdef UNC_CD_TRACE
+ {
+ cerr << "\n ^^^ Construct from double value " << dec << val << ", unc " << unc
+ << ", df " << df << ", types" << showUncTypes(uncTypeFlags) << endl;
+ }
+#endif
+ // Check on value.
+ if (
+ (boost::math::isfinite(value_)) // Value is finite, so neither infinity nor NaN!
+ && (0.0f == uncertainty_) // Uncertainty parameter is zero (default).
+ && (unctypes_ & UNC_KNOWN) // In case UNC_KNOWN flag is cleared by value of uncTypeFlags.
+ // default unc = 0.f to suit construction from a double uncun(2.)
+ // but NOT exact if more than one value or unc unknown signaled.
+ )
+ { // Value is Exact double.
+ //unctypes_ |= VALUE_EXACT;
+ if (value_ == 0.)
+ { // Speed simplest & common zero integer case.
+ unctypes_ |= (VALUE_ZERO | VALUE_INTEGER | VALUE_RATIONAL);
+ }
+ else
+ { // Not exact.
+ // Only if construct from int, then set flag as VALUE_INTEGER.
+ // Else leave unctypes_ as set by constructor, perhaps setting VALUE_INTEGER and/or VALUE_RATIONAL.
+ }
+ }
+ else
+ { // Value is Nan or Infinity.
+ // Use a flag here? VALUE_NONFINITE ??
+ }
+
+ // Check if unc (std dev) is NaN or infinity.
+ if (!boost::math::isfinite(unc))
+ { // unc (std dev) is NaN or infinity.
+ unctypes_ &= ~(UNC_KNOWN | UNC_EXPLICIT| DEG_FREE_EXACT | DEG_FREE_KNOWN) ; // Clear all UNC_KNOWN flag.
+ }
+ else
+ { // unc (stdDev) is finite.
+ if (unc == 0.0f)
+ {
+ unctypes_ |= VALUE_EXACT; // Set.
+ }
+ else if (unc < 0.0f)
+ { // Negative uncertainty.
+ if (!is_correlated) // NOT correlated case.
+ { // Error! Throw? Or set uncertainty to zero?
+ unctypes_ &= ~UNC_KNOWN;
+ std::cerr << "Negative uncertainty " << unc << ", Value " << val << "!" << std::endl;
+ // uncertainty_ = 0.0f; or NaN?
+ }
+ else // is correlated.
+ { // But CAN have negative uncertainty for correlated case.
+ std::cout << "Negative uncertainty for correlated case is not yet implemented." << std::endl;
+ }
+ if (unctypes_ && (UNC_NOPLUS | UNC_NOMINUS | UNC_QUAN_DECIMAL | UNC_QUAN_BINARY | UNC_UNIFORM | UNC_TRIANGULAR | UNC_EXPLICIT) != 0)
+ { // Any uncertainty specifier bit means uncertainty is known.
+ unctypes_ |= UNC_KNOWN; // But do NOT specify as explicit.
+ }
+ }
+ if ((uncTypeFlags & VALUE_EXACT) == VALUE_EXACT)
+ { // Check for a valid uncertainty, but type parameter is exact.
+ if (uncertainty_ != 0.f)
+ {
+ std::cout << "Value " << value_ << " flagged as exact, but uncertainty " << uncertainty_ << " is not zero!" << std::endl;
+ uncertainty_ = 0.f; // Override any unc provided.
+ // This indicates a programmer logic error!
+ }
+ if (degFree_ != 0)
+ {
+ std::cout << "Value " << value_ << " flagged as exact, but degfree " << degFree_ << " is not zero!" << std::endl;
+ degFree_ = 0; // Override any degfree provided.
+ // This indicates a programmer logic error!
+ }
+ } //
+ } // unc finite check
+#ifdef UNC_CD_TRACE
+ {
+ cerr << " Constructed from double: value_ "
+ << value_ << ", m_unc " << uncertainty_ << ", m_df "
+ << dec << degFree_ << ", " << showUncTypes(unctypes_)
+ << endl;
+ }
+#endif
+ }; // unc constructor from double.
+
+ // A specific constructor from int (as well as double) leads to this warning.
+ // #pragma warning (disable : 4520) //!< 'unc<1>' : multiple default constructors specified.
+
+ //!< Constructor from integer value.
+ unc(
+ const int ivalue = 0, // Default value integer zero.
+ const float unc = 0.0f, // Exact.
+ const short unsigned int df = 1, // means observations = 1.
+ const short unsigned int uncTypeFlags = // unc type flags.
+ DEG_FREE_DEF | // See also constructor from double.
+ VALUE_INTEGER | VALUE_RATIONAL | // If integer, must be rational too.
+ UNC_NOPLUS | UNC_NOMINUS | UNC_KNOWN) // Both so Exact.
+ : value_(ivalue),
+ uncertainty_(unc), // Not quite sure if sensible to allow uncertainty?
+ degFree_(df) // OK to allow degrees of freedom (many integers).
+ , unctypes_(uncTypeFlags) // Don't allow this as a parameter to avoid conflicting settings?
+ {
+ if (value_ == 0.)
+ { // Zero integer case.
+ unctypes_ |= VALUE_ZERO;
+ }
+#ifdef UNC_CD_TRACE
+ {
+ cerr << "\n ^^^ Constructed from int: value "
+ << ivalue << ", value_ " << value_ << ", unc " << uncertainty_ << ", df "
+ << dec << degFree_ << ", " << showUncTypes(unctypes_)
+ << endl;
+ }
+#endif
+ } // Constructor from integer value.
+
+ unc(const unc& ud) //!< Constructor copy from another unc.
+ : value_(ud.value_), uncertainty_(ud.uncertainty_),
+ degFree_(ud.degFree_), unctypes_(ud.unctypes_)
+ { // Just copy all 4 member data.
+#ifdef UNC_CD_TRACE
+ {
+ cerr << "\n ^^^ Constructed from unc: value_ "
+ << value_ << ", m_unc " << uncertainty_ << ", m_df "
+ << dec << degFree_ << ", " << showUncTypes(unctypes_)
+ << endl;
+ }
+#endif
+ } // Constructor from unc.
+
+ //! Destructors. Two versions defined in unc.ipp to provide diagnostic output.
+ // ~unc(); // Declaration, .
+
+ // Unary operators + and -.
+ // No change to degrees of freedom or unc_types.
+ // (unc<is_correlated> operator +(void) const; produces:
+ // C2535 member function already defined or declared).
+
+ unc<is_correlated> operator+ (void) const // Unary +
+ { // 'slope' d f(x)/dx = +1
+ return *this; // All members remain unchanged.
+ }
+
+ unc<is_correlated> operator- (void) const // Unary -
+ { // 'slope' d f(x)/dx = -1
+ if (is_correlated) // Negate BOTH value & uncertainty.
+ return unc<is_correlated>(-value_, -uncertainty_);
+ else // Don't negate sign of uncertainty if not correlated, only value.
+ return unc<is_correlated>(-value_, uncertainty_);
+ }
+
+ // Binary add & subtract operators.
+ // (Implemented using += and -= operators).
+ friend unc<is_correlated> operator+ (unc<is_correlated> a,
+ const unc<is_correlated>& b)
+ {
+ return a += b;
+ }
+
+ friend unc<is_correlated> operator+ (unc<is_correlated> a,
+ const double& b)
+ {
+ return a += b;
+ }
+
+ friend unc<is_correlated> operator+ (const double& b,
+ unc<is_correlated> a)
+ {
+ return a += b;
+ }
+
+ friend unc<is_correlated> operator- (unc<is_correlated> a,
+ const unc<is_correlated>& b)
+ {
+ return a -= b;
+ }
+
+ friend unc<is_correlated> operator- (unc<is_correlated> a,
+ const double& b)
+ {
+ return a -= b;
+ }
+
+ friend unc<is_correlated> operator- (const double& b,
+ unc<is_correlated> a)
+ {
+ a -= b; return -a;
+ }
+
+ // Pre-Increment & pre-decrement operators.
+ // (Implemented using += and -= operators).
+ // Since using integer unity, uncertainty & rationality is unchanged.
+ unc<is_correlated> operator++ (void)
+ { return (*this += 1.); }
+
+ unc<is_correlated> operator-- (void)
+ { return (*this -= 1.); }
+
+ unc<is_correlated> operator++ (int)
+ {
+ unc<is_correlated> retval(*this);
+ *this += 1.;
+ return retval;
+ }
+
+ unc<is_correlated> operator-- (int)
+ {
+ unc<is_correlated> retval(*this);
+ *this -= 1.;
+ return retval;
+ }
+
+ // Multiply & divide operators (using *= etc assignment operators).
+ friend unc<is_correlated> operator* (unc<is_correlated> a,
+ const unc<is_correlated>& b)
+ {
+ return a *= b;
+ }
+
+ // Uncertainty unchanged by all operations using a double.
+ friend unc<is_correlated> operator* (unc<is_correlated> a,
+ const double& b)
+ {
+ return a *= b;
+ }
+
+ friend unc<is_correlated> operator* (const double& b,
+ unc<is_correlated> a)
+ {
+ return a *= b;
+ }
+
+ friend unc<is_correlated> operator/ (unc<is_correlated> a,
+ const unc<is_correlated>& b)
+ {
+ return a /= b;
+ }
+
+ friend unc<is_correlated> operator/ (unc<is_correlated> a,
+ const double& b)
+ {
+ return a /= b;
+ }
+
+ friend unc<is_correlated> operator/ (const double& b,
+ unc<is_correlated> a)
+ {
+ unc<is_correlated> retval;
+ retval.uncertainty_ = -b * a.uncertainty_ / (a.value_ * a.value_);
+ retval.value_ = b / a.value_;
+ retval.unctypes_ &= ~(VALUE_RATIONAL | VALUE_INTEGER);
+ // Must assume double b is irrational and NOT integer.
+ // (Use a unc instead to divide by a rational).
+ return retval;
+ }
+
+ // Assignment operators +=, -=, *=, /=
+ // (Used by plain +, -, * and / operators).
+ // If VALUE_NEGATIVE_ONLY might check that value is still < 0?
+ // If VALUE_POSITIVE_ONLY might check that value is still > 0?
+
+ unc<is_correlated>& operator+= (const unc<is_correlated>& ud)
+ { // unc += unc
+ if (is_correlated)
+ {
+ uncertainty_ += ud.uncertainty_; // If correlated then just add.
+ degFree_ = // Choose degrees of freedom of the max uncertainty.
+ (uncertainty_ > ud.uncertainty_) ? degFree_ : ud.degFree_;
+ // Exact method of estimating not known, but is a reasonable approximation
+ // provided really is highly correlated because less well predicted
+ // variance can be predicted well with the better predicted.
+ // See email from Steve LR Ellison, Lab of Government Chem, 24 Apr 98.
+ }
+ else
+ { // Uncorrelated so Propagation of Uncertainty rules apply.
+ // Barry N Taylor & Chris E Kuyatt, NIST Technical note 1297 (1994),
+ // Guidelines for Evaluating & Expressing the Uncertainty of Measurements.
+ // http:// physics.nist.gov/pubs/guidelines.appa.html
+ // 'Combined uncertainty' Appendix A formula A-3 = "sqrt(sum of squares)"
+ double comb_uncertainty = sqrtSumSqrs(uncertainty_, ud.uncertainty_);
+ degFree_ = // Welch-Satterthwaite - see NIST Appendix A3 & Appendix B-1.
+ // Effective degrees of freedom <= - see Eq B-2, so use floor function.
+ static_cast<unsigned short>( // Degrees of freedom must be integer by definition.
+ floor(
+ pow4<double>(comb_uncertainty)/
+ (pow4<double>(uncertainty_)/degFree_ + pow4<double>(ud.uncertainty_) / ud.degFree_))
+ );
+ uncertainty_ = float(comb_uncertainty);
+ }
+ unctypes_ &= ~DEG_FREE_EXACT; // This warns of an approximation - no longer exact.
+ unctypes_ &= ud.unctypes_; // Imposes rules for all additions of uncs.
+ // zero + zero = zero, restrictions on pos & neg only only retained if both,
+ // int + int is int, rational + rational is rational, int + rational is rational.
+ // either or both plusminus same if BOTH.
+ // Quantisation retains only if both.
+ value_ += ud.value_;
+ return *this;
+ }
+
+ operator value_type() const
+ {
+ return value_;
+ }
+
+ unc<is_correlated>& operator+= (const double& a)
+ { // unc += double
+ value_ += a;
+ // Uncertainty & Degrees of freedom both unchanged.
+ unctypes_ &= ~(VALUE_ZERO | VALUE_RATIONAL | VALUE_INTEGER | VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY);
+ // All restrictions on value removed.
+ return *this;
+ }
+
+ unc<is_correlated>& operator-= (const unc<is_correlated>& ud)
+ { // unc -= double
+ if (is_correlated)
+ { // Correlated.
+ uncertainty_ -= ud.uncertainty_;
+ degFree_ = // Biggest - see +=
+ (uncertainty_ > ud.uncertainty_) ? degFree_ : ud.degFree_;
+ }
+ else
+ { // Uncorrelated.
+ float comb_uncertainty = sqrtSumSqrs(uncertainty_, ud.uncertainty_);
+ degFree_ = // Welch-Satterthwaite - see NIST Appendix A3 Appendix B-1.
+ (unsigned short) // Must be integer by definition.
+ floor( // Round or floor?
+ pow4(comb_uncertainty)/
+ (pow4(uncertainty_)/degFree_+pow4(ud.uncertainty_)/ud.degFree_)
+ );
+ uncertainty_ = float(comb_uncertainty);
+
+ }
+ unctypes_ &= ~DEG_FREE_EXACT; // No longer exact.
+ unctypes_ &= ud.unctypes_; // See += operator.
+ value_ -= ud.value_;
+ return *this;
+ }
+
+ unc<is_correlated>& operator-= (const double& a)
+ {
+ value_ -= a;
+ // Uncertainty & Degrees of freedom both unchanged.
+ unctypes_ &= ~(VALUE_ZERO | VALUE_RATIONAL | VALUE_INTEGER | VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY);
+ // All indicators & restrictions on value removed.
+ return *this;
+ }
+
+ unc<is_correlated>& operator*= (const unc<is_correlated>& ud)
+ {
+ if (is_correlated)
+ {
+ uncertainty_ = float(uncertainty_ * ud.value_ + ud.uncertainty_ * value_);
+ degFree_ = // Choose degrees of freedom of the max uncertainty.
+ (uncertainty_ > ud.uncertainty_) ? degFree_ : ud.degFree_;
+ }
+ else // Uncorrelated.
+ {
+ double comb_uncertainty =
+ sqrtSumSqrs(uncertainty_ * ud.value_, ud.uncertainty_ * value_);
+ degFree_ = // Welch-Satterthwaite - see NIST Appendix A3 Appendix B-1.
+ static_cast<unsigned short> ( // must be integer by definition. Round or floor?
+ pow4(comb_uncertainty)/
+ (pow4(uncertainty_)/degFree_+pow4(ud.uncertainty_)/ud.degFree_) );
+ uncertainty_ = float(comb_uncertainty);
+ }
+ unctypes_ &= ~DEG_FREE_EXACT; // No longer exact.
+ unctypes_ &= ud.unctypes_; //
+ value_ *= ud.value_;
+ return *this;
+ }
+
+ unc<is_correlated>& operator*= (const double& a)
+ {
+ value_ *= a;
+ uncertainty_ *= (float)a; // Relative uncertainty unchanged.
+ // Multiplying by constant doesn't change degrees of freedom.
+ unctypes_ &= ~(VALUE_ZERO | VALUE_RATIONAL | VALUE_INTEGER | VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY);
+ // All indicators & restrictions on value removed.
+ return *this;
+ }
+
+ unc<is_correlated>& operator/= (const unc<is_correlated>& ud)
+ { // unc /= unc
+ if (is_correlated)
+ { // Correlated.
+ uncertainty_ = uncertainty_ / ud.value_
+ - (ud.uncertainty_ * value_) / (ud.value_ * ud.value_);
+ degFree_ = // Choose degrees of freedom of the max uncertainty.
+ (uncertainty_ > ud.uncertainty_) ? degFree_ : ud.degFree_;
+ }
+ else
+ { // Uncorrelated.
+ float comb_uncertainty = sqrtSumSqrs(uncertainty_ / ud.value_,
+ (ud.uncertainty_ * value_) / (ud.value_ * ud.value_));
+ degFree_ = // Welch-Satterthwaite - see NIST Appendix A3 Appendix B-1.
+ (int) // must be integer by definition. Round or floor?
+ pow4(comb_uncertainty)/
+ (pow4(uncertainty_)/degFree_+pow4(ud.uncertainty_)/ud.degFree_);
+ uncertainty_ = float(comb_uncertainty);
+ }
+ unctypes_ &= ~DEG_FREE_EXACT; // No longer exact.
+ if ((unctypes_ & VALUE_INTEGER) && (ud.unctypes_ & VALUE_INTEGER) )
+ { // int / int
+ unctypes_ |= VALUE_RATIONAL; // becomes rational,
+ unctypes_ &= ~VALUE_INTEGER; // but no longer int.
+ }
+ else
+ {// rational / rational is still rational.
+ unctypes_ &= ud.unctypes_;
+ }
+ if (ud.unctypes_ & VALUE_ZERO != 0)
+ { // Avoid divide by zero, unless both zero!
+ value_ = (value_ != 0.) ? INFINITY : 0.;
+ }
+ else
+ { // Probably safe to divide. Check value == 0 as well??
+ value_ /= ud.value_;
+ }
+ { // Check if result is really an integer.
+ double i; // For integer part from modf.
+ double frac = modf(value_, &i); // modf only works for doubles,
+ // so can't test frac = 0.0f and this is better anyway.
+ if (frac <= std::numeric_limits<double>::epsilon()) // nearly == 0
+ // numeric_limits<double>::epsilon() = 2.22045e-016 aka DBL_EPSILON
+ {
+ unctypes_ |= (VALUE_INTEGER | VALUE_RATIONAL);
+ }
+ // TODO Any perhaps check if value is (near) zero?
+ }
+ return *this;
+ }
+
+ /*! operator /=
+ \note Dividing by constant doesn't change degrees of freedom or uncertainty.
+ All indicators & restrictions on value removed.
+ Must assume double is irrational and not integer,
+ NOT int/int becomes rational as operator /= .
+ */
+ unc<is_correlated>& operator/= (const double& a)
+ {
+ value_ /= a;
+ uncertainty_ /= float(a);
+ unctypes_ &= ~(VALUE_ZERO | VALUE_RATIONAL | VALUE_INTEGER | VALUE_NEGATIVE_ONLY | VALUE_POSITIVE_ONLY);
+ return *this;
+ }
+
+ inline bool operator== (const unc<is_correlated>& x) const
+ { // Predicate compare equal.
+ return value_ == x.value_; // Compare values EXACTLY.
+ // Might also close_to compare within uncertainty - see equalU
+ } // operator==
+
+ inline bool operator!= (const unc<is_correlated>& x) const
+ { // Predicate compare not equal.
+ return value_ != x.value_; // Compare values EXACTLY.
+ // Might also close_to compare within uncertainty - see equalU
+ } // operator!=
+
+ inline bool operator< (const unc<is_correlated>& x) const
+ { // Predicate compare operator< for use by std::sort etc.
+ // (Note const needed to use with less!)
+ return value_ < x.value_;
+ // Use normal signed values (no allowance for uncertainties).
+ // Might also compare within uncertainty - see lessU
+ } // operator<
+
+ // Insert and extract operator>> and operator<< for unc.
+ friend std::ostream& operator<< (std::ostream& os, const unc<is_correlated>& val)
+ {
+ boost::io::ios_precision_saver precision_saver(os);
+ boost::io::ios_flags_saver flags_saver(os);
+ // Changes are restored on destruction.
+ std::ostringstream oss; // Build up string.
+ oss.flags(os.flags()); // Copy flags to restore TODO not needed?).
+
+ double mean = val.mean();
+ float uncertainty = val.deviation();
+ unsigned short int degFree = val.degFree();
+ unsigned short int unc_flags = val.uncFlags();
+
+ // bools showing output requirements specified using unc additional ostream manipulators.
+ // Note that these bools are NOT initialised here,
+ // assuming compiler will warn if used before being initialised.
+ /*
+ \var bool isNoisyDigit
+ \brief Add an extra 'noisy' guard digit to reduce risk of information loss.
+ */
+ bool isNoisyDigit; //!<
+ bool isDegFree; //!< Append degrees of freedom.
+ bool isPlusMinus; //!< Uncertainty as +/- is required too (but ignore if value is exact or integer).
+ bool isUppercase; //!< Exponential format is, for example, 1E6 else 1e6.
+ bool isScientificFormat; //!< Taken to mean that exponential format wanted (always possible).
+ bool isShowPoint; //!< Means decimal point is always shown, for example 900. even if not needed.
+ bool isShowPos; //!< Show + sign always because ios flag was set with `<< showpo`s.
+ bool isFixed; //!< `os << fixed ...` ios decimal fixed d.dddd format (rather than scientific).
+ bool isWidthSet; //!< `os << setw(9)` has prescribed a width (rather than default width == 0).
+ bool isNoAdjust; //!< std = default but unc usage not defined yet, center?
+ bool isRightJustify; //!< right justify, prepend leading pad before. `<< right << ...`
+ bool isLeftJustify; //!< left justify, append trailing pad after. `<< left ...`
+ bool isInternalJustify; //!< Not defined yet, but use to center in field?
+ bool isCenter; //!< center if BOTH left and right specified.
+ bool isAlign; //!< Align on decimal point?
+ bool isConfidenceInterval; //!< Append confidence interval, for example, "<1.23, 1.56>"
+ bool isSetSigDigits; //!< Use set sigdigits instead of calculate from uncertainty.
+ bool isSetUncSigDigits; //!< Use set sigdigits instead of calculate from uncertainty.
+ // Get print format requirements from std::ios flags. ****************************
+ const int iosFlags = os.flags(); // Save fmtflags in case need to restore.
+
+ // Width, precision, flags & fillChar data from stream os. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ std::streamsize iosWidth = os.width(); //!< \warning Width must be read BEFORE any use of os
+ // which would reset width back to zero!
+ // & prevent any ios formatting during os << ...
+ // because unc_output does all its own formatting.
+ isWidthSet = (iosWidth > 0); // For example by os << setw(99)
+
+ isUppercase = static_cast<bool>(iosFlags & std::ios_base::uppercase); // E not e.
+ // TODO No mechanism to change uppercase at present in round_* functions.
+ isScientificFormat = static_cast<bool>(iosFlags & std::ios_base::scientific); // exp format wanted.
+ isFixed = static_cast<bool>(iosFlags & std::ios_base::fixed); // `<< fixed` Fixed format wanted.
+ // means d.dddd format wanted, if possible, rather than scientific or exp format.
+ isNoAdjust = !static_cast<bool>(iosFlags & std::ios_base::adjustfield); // `<< noadjust`
+ // no adjustfield flags are set (default, and == << right - a waste!).
+ isLeftJustify = static_cast<bool>(iosFlags & std::ios_base::left);
+ // left justify, append trailing padding with fillchar after.
+ isRightJustify = static_cast<bool>(iosFlags & std::ios_base::right);
+ // right justify, prepend leading padding with fillchar before.
+ isInternalJustify = static_cast<bool>(iosFlags & std::ios_base::internal);
+ // IO streams use to output fill char between sign and 1st digit.
+ // And meaning of more than one bit is specially defined for unc_output:
+ isCenter = isLeftJustify && isRightJustify;
+ // center if BOTH left and right ios specified.
+ // Done with ` << ` center rather than `<< left << right ... `.
+ isAlign = isInternalJustify && isLeftJustify && isRightJustify;
+ // Align decimal point with previous value?
+
+ isShowPoint = static_cast<bool>(iosFlags & std::ios_base::showpoint);
+ // Means decimal point is always shown, for example 900. even if not needed.
+ isShowPos = static_cast<bool>(iosFlags & std::ios_base::showpos);
+ // Show + sign always.
+
+ // Get print format requirements from unc flags.
+ long& uncFlags = os.iword(uncFlagsIndex); //
+ isPlusMinus = static_cast<bool>(uncFlags & plusMinus); // `<< plusminus`
+ isNoisyDigit = static_cast<bool>(uncFlags & noisyDigit); // `<< addNoisyDigit`
+ isConfidenceInterval = static_cast<bool>(uncFlags & limits); // `<< addlimits`
+ isDegFree = static_cast<bool>(uncFlags & degfree); // `<< addDegrees`
+ isSetSigDigits = static_cast<bool>(uncFlags & useSetSigDigits); // `<< setsigdigits`
+ isSetUncSigDigits = static_cast<bool>(uncFlags & useSetUncSigDigits); // `<< setsigdigits`
+
+ // Pick up distribution type from unc_flags.
+ // UNC_UNIFORM = 1 << 11, //!< Uncertainty has rectangular or uniform probability distribution.
+ // UNC_TRIANGULAR = 1 << 12, //!< Uncertainty has triangular probability distribution.
+ distribution_type distrib;
+ if (unc_flags & UNC_UNIFORM)
+ {
+ distrib = uniform;
+ }
+ else if (unc_flags & UNC_TRIANGULAR)
+ {
+ distrib = triangular;
+ }
+ else
+ {
+ distrib = gaussian;
+ }
+
+ long& roundloss = os.iword(roundingLossIndex);
+ double epsilon;
+ if (roundloss == 0)
+ { // Not been set,
+ epsilon = 0.05; // so use a default.
+ }
+ else
+ { // Has been set by a call like `out << confidence(0.01);`.
+ // rounding loss is stored as a long, so scaled by 1000,
+ // so that 0.05 or 1% is stored as 50.
+ epsilon = roundloss / 1000.; // `<< roundingloss(0.05)`
+ }
+ //! Confidence or alpha to compute confidence interval is similarly scaled.
+ //! Usage: `out << confidence(0.01) << ...` means 1 - confidence = 99% confidence.
+ //! double confidence = os.iword(conf) / 1000.; // `<< confidence(0.05)` aka 95%
+
+ //int round_m(double epsilon = 0.01, double unc = 0., unsigned int uncsigdigits = 2, distribution_type distrib = gaussian);
+ //void out_confidence_interval(std::pair<double, double> ci, int m, std::ostream& os = std::cout);
+ //void out_value_limits(double mean, double unc, std::pair<double, double> ci, int m, std::ostream& os = std::cout);
+
+ long& conf = os.iword(confidenceIndex);
+ double confidence;
+ if (conf <= 0)
+ { // Has not been set, so use default.
+ confidence = 0.05; // 95% confidence.
+ }
+ else
+ {
+ confidence = conf / 1.e6;
+ }
+ using boost::math::isfinite;
+ using boost::math::isnan;
+ using boost::math::isinf;
+
+ double intpart;
+ int max_digits10 = std::numeric_limits<double>::digits10 * 3010/10000;
+ // std::numeric_limits<double>::max_digits10))
+ if (boost::math::isfinite(mean))
+ {
+ if(isSetSigDigits)
+ { // Use explicit number of digits of precision.
+ long& sigDigits = os.iword(setSigDigitsIndex);
+ if ((sigDigits <= 0) || (sigDigits > max_digits10) )
+ { // show all potentially significant digits.
+ sigDigits = max_digits10;
+ }
+ oss << std::showpoint << std::setprecision(sigDigits) << mean;
+ }
+ else
+ { // Use uncertainty to control digits of precision.
+ if (mean == 0)
+ { // isValueZero = true;
+ if ((uncertainty == 0.F) )
+ { // Is exact integer zero, so not rounded, and no decimal point.
+ oss << "0";
+ }
+ else if (!isfinite(uncertainty))
+ { // Show all possibly significant digits for NaN and inf uncertainty.
+ oss << std::showpoint << std::setprecision(max_digits10) << mean;
+ }
+ else
+ { // Inexact zero.
+ int m = round_m(epsilon, uncertainty, 2, distrib);
+ if (isNoisyDigit)
+ { // Move rounding digit to one less significant position.
+ m--;
+ }
+ oss << round_ms(0., m);
+ }
+ } // mean == 0
+ else if(unc_flags & VALUE_INTEGER)
+ { // Value is flagged as an integer (used integer constructor or set flag).
+ double fracpart = std::modf(mean, &intpart);
+ oss << static_cast<long>(intpart); // Integer, so not rounded, and no decimal point,
+ // even if decimal point is specified by showpoint!
+ }
+ else if (unc_flags & VALUE_EXACT)
+ { // Value flagged as exact because sd == 0 (but NOT integer)
+ // (used double constructor or set flag) so show decimal point.
+ oss.unsetf(std::ios_base::showpoint); // Ignore showpoint so NO trailing zeros.
+ // Kinda want a decimal point here, but causes trouble with setw :-(
+ oss << std::setprecision(std::numeric_limits<double>::digits10) << mean;
+ double fracpart = std::modf(mean, &intpart);
+ if (fracpart == 0.)
+ { // Avoid two decimal points!
+ oss << '.';
+ }
+ }
+ else
+ { // Non-zero uncertainty, sd != 0.
+ if (isfinite(uncertainty))
+ { // Rounding is appropriate.
+ int m = round_m(epsilon, uncertainty, 2, distrib); // m is rounding digit index.
+ if (isNoisyDigit)
+ { // Move rounding digit to one less significant position.
+ m--;
+ }
+ if (isShowPos)
+ {
+ oss << '+';
+ }
+ if (mean <= 1e15)
+ { // Will fit into 1000000000000 (digits10 = 15).
+ oss << round_ms(mean, m);
+ }
+ else
+ { // Won't fit into 1000000000000 (digits10 = 15), so switch to exponent format.
+ oss << mean;
+ //round_e(mean, m); // This value of m is wrong TODO !!!
+ // Need to round but and not display exp as "e+009" TODO.
+ }
+ }
+ else
+ { // Uncertainty NAN or infinite, so show all possibly significant digits.
+ oss << std::showpoint << std::setprecision(max_digits10) << mean;
+ }
+ }
+ }
+ }
+ else
+ { // Mean is NaN or infinity.
+ if (isnan(mean))
+ {
+ oss << "NaN" ;
+ }
+ else if (isinf(mean))
+ {
+ oss << ((mean < 0) ? "-inf" : (isShowPos) ? "+inf" : "inf");
+ }
+ // Or could leave as native output, but MSVC format is ugly.
+ } // Mean
+
+ if (isPlusMinus && !(unc_flags & VALUE_INTEGER))
+ { // Want estimate of uncertainty.
+ if (isfinite(uncertainty))
+ {
+ if (uncertainty == 0.F)
+ { // Special case short version.
+ oss << " +/-0";
+ }
+ else
+ { // Non-zero uncertainty.
+ int uncSigDigits = os.iword(setUncSigDigitsIndex);
+ // Default is round to 2 sig digit - ISO rule.
+ if (uncSigDigits <= 0)
+ { // Automatically choose uncSigDigits based on degrees of freedom.
+ // Passed negative values through to allow
+ // an auto mode for w < 0 that chooses from degrees of freedom,
+ // From table H page 457 in Oliver & Goldsmith, confidence interval
+ // of standard deviation is about +/- 20% at 10 degrees of freedom,
+ // and only < +/- 10% above 100 observations (needing 2 stdDev sig Digits).
+ uncSigDigits = abs(uncSigDigits);
+ if (degFree > 100)
+ {
+ uncSigDigits = 3;
+ }
+ else if (degFree > 10)
+ {
+ uncSigDigits = 2;
+ }
+ else
+ { // degFree in common range 1 to 10.
+ // Choose between 1 and 2 digits based on 1st digit of uncertainty.
+ // Would be too big a step if most significant digit was 1 or 2.
+ std::ostringstream oss;
+ oss << std::scientific << std::setprecision (1) << uncertainty; // Assume sd positive.
+ if(oss.str()[0] == '1') // Check 1st digit before decimal point.
+ { // Would be too big a step if most significant digit was 1 or 2.
+ uncSigDigits = 2;
+ }
+ else if (oss.str()[0] == '2')
+ {
+ uncSigDigits = 2;
+ }
+ else
+ { // 1st digit > 2 so can use just 1 digit.
+ uncSigDigits = 1;
+ }
+ }
+ }
+
+ if (unc_flags & UNC_NOPLUS)
+ {
+ oss << " +0/-";
+ }
+ else if (unc_flags & UNC_NOMINUS)
+ {
+ oss << " -0/+";
+ }
+ else
+ { // normal plus and minus.
+ oss << " +/-";
+ }
+ //oss.unsetf(std::ios_base::scientific);
+ oss << std::noshowpos // Prefixed by " +/-" so never add +.
+ << std::fixed // << std::noscientific
+ << std::showpoint
+ << std::setprecision(uncSigDigits); // switches to e format :-(
+ //double unc_rounded = round_sig(uncertainty, uncSigDigits);
+ //oss << unc_rounded;
+ //std::string round_f<FPT>(FPT v, int sigdigits);
+ std::string s = round_f<float>(uncertainty, uncSigDigits);
+ oss << s;
+ }
+ }
+ else
+ { // Not finite uncertainty - NaN or inf.
+ if (isnan(uncertainty))
+ {
+ oss << " +/-?";
+ }
+ else if (isinf(uncertainty))
+ {
+ oss << " +/-inf";
+ }
+ }
+ } // uncertainty.
+
+ if(isConfidenceInterval)
+ { // Want to append confidence interval as <1.23, 2.34>.
+ if (boost::math::isfinite(mean) && boost::math::isfinite(uncertainty) && degFree >= 1)
+ { // Possible to compute confidence limits or interval in < > angle brackets.
+ std::streamsize osp = os.precision();
+ oss.precision(4); //
+ //std::pair<double, double> conf_interval(double mean, double unc, double df = 1., double alpha = 0.05, distribution_type distrib = gaussian);
+ double alpha = os.iword(confidenceIndex) / 1.e6; // Pick up and unscale alpha.
+ double epsilon = os.iword(roundingLossIndex) / 1.e3; // Pick up and rounding loss and unscale.
+ int uncSigDigits = os.iword(setUncSigDigitsIndex); // Pick up significant digits for uncertainty.
+ if(isNoisyDigit)
+ {
+ uncSigDigits++;
+ }
+ std::pair<double, double> ci = conf_interval(mean, uncertainty, degFree, alpha, distrib);
+ int m = round_m(epsilon, uncertainty, uncSigDigits, distrib);
+ using boost::lexical_cast;
+ oss << " <"
+ << lexical_cast<double>(round_ms(ci.first, m-1)) << ", "
+ << lexical_cast<double>(round_ms(ci.second, m-1))
+ << ">";
+ }
+ else
+ { // Not possible to compute confidence limits or interval.
+ oss << " < ? >" ;
+ }
+ } // Appended confidence interval.
+
+ if (isDegFree)
+ {
+ if (degFree == (std::numeric_limits<unsigned short int>::max)())
+ { // Is valid.
+ oss << " (?)";
+ }
+ else if (degFree == 0u)
+ {
+ oss << " (0?)";
+
+ }
+ else
+ {
+ oss << " (" << degFree << ")";
+ }
+
+ }
+ os << oss.str();
+ return os;
+ } // friend ostream& operator<< (ostream& os, const unc<is_correlated>& val)
+
+ friend std::istream& operator>> (std::istream& is, unc<is_correlated>& ud)
+ {
+ double mean;
+ double stdDev;
+ unsigned short int degreesOfFreedom;
+ unsigned short unctypes;
+ unc_input(mean, stdDev, degreesOfFreedom, unctypes, is);
+ // At present, uses a separate function for input (unlike output).
+ ud = unc<is_correlated>(mean, float(stdDev), degreesOfFreedom, unctypes);
+ // Inputs mean, SD & degrees of freedom & set unc types...
+ return is;
+ }
+
+ // Math functions for uncertain class.
+ friend unc<is_correlated> ceil(unc<is_correlated> arg)
+ {
+ arg.value_ = ceil(arg.value_);
+ arg.uncertainty_ = 0.; // Becomes exact & rational integer.
+ arg.unctypes_ |= UNC_NOPLUS | UNC_NOMINUS | VALUE_INTEGER | VALUE_RATIONAL; // Exact.
+ arg.degFree_ = (std::numeric_limits<unsigned short>::max)(); //= USHRT_MAX; = 0xFFFF
+ return arg;
+ }
+
+ friend unc<is_correlated> floor(unc<is_correlated> arg)
+ {
+ arg.value_ = floor(arg.value_);
+ arg.uncertainty_ = 0.; // Becomes exact & rational integer.
+ arg.unctypes_ |= UNC_NOPLUS | UNC_NOMINUS| VALUE_INTEGER | VALUE_RATIONAL; // Exact.
+ arg.degFree_ = (std::numeric_limits<unsigned short>::max)(); // USHRT_MAX; = 0xFFFF
+ return arg;
+ }
+
+ friend unc<is_correlated> fabs(unc<is_correlated> arg)
+ {
+ if (is_correlated && (arg.value_ < 0.))
+ arg.uncertainty_ *= -1.;
+ // Else uncorrelated so uncertainty unchanged?
+ arg.value_ = fabs(arg.value_);
+ unsigned short int plusMinus = arg.unctypes_ & (UNC_NOPLUS | UNC_NOMINUS);
+ if (( plusMinus != 0) // Neither, & not both
+ && (plusMinus != (UNC_NOPLUS | UNC_NOMINUS))
+ )
+ { // Just one asymetric uncertainty.
+ plusMinus = ~plusMinus; // Switch bits over.
+ arg.unctypes_ &= ~(UNC_NOPLUS | UNC_NOMINUS); // Clear both.
+ arg.unctypes_ |= plusMinus; // Set switched.
+ }
+ return arg;
+ }
+
+ friend unc<is_correlated> abs(unc<is_correlated> arg)
+ { // Copy of fabs version above.
+ if (is_correlated && (arg.value_ < 0.))
+ arg.uncertainty_ *= -1.;
+ // Else uncorrelated so uncertainty unchanged?
+ arg.value_ = fabs(arg.value_);
+ unsigned short int plusMinus = arg.unctypes_ & (UNC_NOPLUS | UNC_NOMINUS);
+ if (( plusMinus != 0) // Neither, & not both
+ && (plusMinus != (UNC_NOPLUS | UNC_NOMINUS))
+ )
+ { // Just one asymetric uncertainty.
+ plusMinus = ~plusMinus; // Switch bits over.
+ arg.unctypes_ &= ~(UNC_NOPLUS | UNC_NOMINUS); // Clear both.
+ arg.unctypes_ |= plusMinus; // Set switched.
+ }
+ return arg;
+ }
+
+
+ friend unc<is_correlated> ldexp(unc<is_correlated> arg,
+ int intarg) // Real from significand or mantissa arg & exponent intarg.
+ {
+ if (is_correlated)
+ arg.uncertainty_ *= ldexp(1., intarg);
+ else
+ arg.uncertainty_ *= fabs(ldexp(1., intarg));
+ arg.value_ = ldexp(arg.value_, intarg);
+ arg.unctypes_ &= ~(UNC_KNOWN | UNC_NOPLUS | UNC_NOMINUS); //
+ return arg; // arg * 2**intarg
+ }
+
+ friend unc<is_correlated> modf(unc<is_correlated> arg, double* intpart)
+ { // Split unc into updated integer and return fraction parts.
+ arg.value_ = modf(arg.value_, intpart); // value = fractional part.
+ // Must assume not rational fraction, so clear many bits.
+ arg.unctypes_ &= ~(VALUE_INTEGER | VALUE_RATIONAL | UNC_KNOWN | UNC_NOPLUS | UNC_NOMINUS | UNC_EXPLICIT | DEG_FREE_EXACT | DEG_FREE_KNOWN);
+ return arg; // Fractional part (mantissa or significant).
+ }
+
+ friend unc<is_correlated> frexp(unc<is_correlated> arg, int* intarg)
+ { // Raise arg to integer power.
+ arg.uncertainty_ *= float(pow(2., double(-*intarg)));
+ arg.value_ = frexp(arg.value_, intarg);
+ // If zero, integer or rational remains so.
+ return arg;
+ }
+
+ friend unc<is_correlated> fmod(const unc<is_correlated>& arg,
+ const unc<is_correlated>& divisor)
+ { // Floating-point remainder of x / divisor such that
+ // x = i * divisor + remainder,
+ // where i is an integer, remainder has the same sign as x, and
+ // absolute value of remainder is less than the absolute value of y.
+ unc<is_correlated> remainder(0.); // For remainder.
+ if (divisor.value_ == 0.)
+ { // ANSI 4.5.6.4 if divisor == zero return zero.
+ remainder.value_ = 0.;
+ remainder.uncertainty_ = std::numeric_limits<float>::infinity();
+ remainder.unctypes_ = 0U; //
+ }
+ else
+ {
+ double slope1 = 1. / divisor.value_; // If zero would cause divide by zero!
+ double slope2 = ((arg.value_ / divisor.value_) > 0.) ?
+ -floor(arg.value_ / divisor.value_) :
+ floor(-arg.value_ / divisor.value_);
+ if (is_correlated)
+ remainder.uncertainty_ = float(slope1 * arg.uncertainty_
+ + slope2 * divisor.uncertainty_);
+ else
+ remainder.uncertainty_ = float(sqrtSumSqrs(slope1 * arg.uncertainty_,
+ slope2 * divisor.uncertainty_));
+ remainder.value_ = fmod(arg.value_, divisor.value_);
+ remainder.unctypes_ = arg.unctypes_; // Better choice than divisor?
+ remainder.unctypes_ &= ~(VALUE_INTEGER | VALUE_RATIONAL);
+ // Remainder can't be integer & unlikely to be rational, so clear these.
+ }
+ return remainder; // remainder.
+ }
+
+ friend unc<is_correlated> sqrt(unc<is_correlated> arg)
+ { // sqrt(unc)
+ arg.value_ = sqrt(arg.value_);
+ if (is_correlated)
+ arg.uncertainty_ /= 2. * arg.value_;
+ else // Uncorrelated.
+ arg.uncertainty_ /= fabs(2. * arg.value_);
+ arg.unctypes_ &= ~(VALUE_INTEGER); // Must assume not integer.
+ // sqrt of rational reamins rational?
+ return arg;
+ }
+
+ friend unc<is_correlated> sin(unc<is_correlated> arg)
+ {
+ if (is_correlated)
+ arg.uncertainty_ *= cos(arg.value_);
+ else
+ arg.uncertainty_ *= fabs(cos(arg.value_));
+ arg.value_ = sin(arg.value_);
+ arg.unctypes_ &= ~(VALUE_INTEGER | VALUE_RATIONAL); // Must assume not.
+ return arg;
+ }
+
+ friend unc<is_correlated> cos(unc<is_correlated> arg)
+ {
+ if (is_correlated)
+ arg.uncertainty_ *= -sin(arg.value_);
+ else
+ arg.uncertainty_ *= fabs(sin(arg.value_));
+ arg.value_ = cos(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> tan(unc<is_correlated> arg)
+ {
+ double costemp = cos(arg.value_);
+ arg.uncertainty_ /= costemp * costemp;
+ arg.value_ = tan(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> asin(unc<is_correlated> arg)
+ {
+ arg.uncertainty_ /= sqrt(1. - arg.value_ * arg.value_);
+ arg.value_ = asin(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> acos(unc<is_correlated> arg)
+ {
+ if (is_correlated)
+ arg.uncertainty_ /= -sqrt(1. - arg.value_ * arg.value_);
+ else
+ arg.uncertainty_ /= sqrt(1. - arg.value_ * arg.value_);
+ arg.value_ = acos(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> atan(unc<is_correlated> arg)
+ {
+ arg.uncertainty_ /= 1. + arg.value_ * arg.value_;
+ arg.value_ = atan(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> atan2(const unc<is_correlated>& arg1,
+ const unc<is_correlated>& arg2)
+ {
+ unc<is_correlated> retval;
+ double slope1 = 1., slope2 = 1.; // slope = d f(x)/dx or f'(x).
+ double sum2 = arg2.value_ * arg2.value_ + arg1.value_ * arg1.value_;
+ if (sum2 != 0.)
+ {
+ slope1 = arg2.value_ / sum2;
+ slope2 = -arg1.value_ / sum2;
+ }
+ if (is_correlated)
+ {
+ retval.uncertainty_ = slope1 * arg1.uncertainty_
+ + slope2 * arg2.uncertainty_;
+ }
+ else
+ { // Uncorrelated.
+ retval.uncertainty_ = sqrtSumSqrs(slope1 * arg1.uncertainty_,
+ slope2 * arg2.uncertainty_);
+ }
+ retval.value_ = atan2(arg1.value_, arg2.value_);
+ return retval;
+ }
+
+ friend unc<is_correlated> exp(unc<is_correlated> arg)
+ {
+ arg.value_ = exp(arg.value_);
+ if (is_correlated)
+ arg.uncertainty_ *= arg.value_;
+ else
+ arg.uncertainty_ *= fabs(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> log(unc<is_correlated> arg)
+ {
+ if (is_correlated)
+ arg.uncertainty_ /= arg.value_;
+ else
+ arg.uncertainty_ /= fabs(arg.value_);
+ arg.value_ = log(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> log10(unc<is_correlated> arg)
+ {
+ const double oneDivLog10 = 0.434294481903251827651128918917;
+ // Use Boost.Math?
+ if (is_correlated)
+ arg.uncertainty_ *= oneDivLog10 / arg.value_;
+ else
+ arg.uncertainty_ *= oneDivLog10 / fabs(arg.value_);
+ arg.value_ = log10(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> sinh(unc<is_correlated> arg)
+ {
+ arg.uncertainty_ *= cosh(arg.value_);
+ arg.value_ = sinh(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> cosh(unc<is_correlated> arg)
+ {
+ if (is_correlated)
+ arg.uncertainty_ *= sinh(arg.value_);
+ else
+ arg.uncertainty_ *= fabs(sinh(arg.value_));
+ arg.value_ = cosh(arg.value_);
+ return arg;
+ }
+
+ friend unc<is_correlated> tanh(unc<is_correlated> arg)
+ {
+ double coshtemp = cosh(arg.value_);
+ arg.uncertainty_ /= coshtemp * coshtemp;
+ arg.value_ = tanh(arg.value_);
+ return arg;
+ }
+
+ // Power
+ friend unc<is_correlated> pow(const unc<is_correlated>& arg1,
+ const unc<is_correlated>& arg2)
+ {
+ unc<is_correlated> retval;
+ retval.value_ = pow(arg1.value_, arg2.value_);
+ double slope1, slope2;
+
+ if (0 == arg1.value_)
+ {
+ slope2 = 0.; slope1 = 0.;
+ if (1. == arg2.value_)
+ slope1 = 1.;
+ }
+ else if (arg1.value_ < 0.)
+ { // pow(arg1, arg2) for arg1 < 0. is only defined for integer arg2.
+ slope1 = arg2.value_ * retval.value_ / arg1.value_;
+ slope2 = 0.;
+ }
+ else
+ {
+ slope1 = arg2.value_ * retval.value_ / arg1.value_;
+ slope2 = log(arg1.value_) * retval.value_;
+ }
+ if (is_correlated)
+ retval.uncertainty_ = slope1 * arg1.uncertainty_
+ + slope2 * arg2.uncertainty_;
+ else
+ retval.uncertainty_ = sqrtSumSqrs(slope1 * arg1.uncertainty_,
+ slope2 * arg2.uncertainty_);
+ return retval;
+ }
+
+ // Getter functions for read-only access to private data members:
+ // uncertainty_, value_, degrees of freedom and unc type.
+
+ // These are duplicates.
+
+ double mean(void) const {return value_;}
+
+ float deviation(void) const {return uncertainty_;} //
+
+ unsigned short int degFree(void) const {return degFree_;}
+
+ unsigned short int uncFlags(void) const {return unctypes_;} // 16 flags.
+
+ // For testing single argument functions like sin,cos, tan, log, exp.
+ friend unc<is_correlated> PropagateUncertaintiesBySlope(
+ double (* certain_func)(double), // For example sin
+ const unc<is_correlated>& arg) // (angle)
+ {
+ unc<is_correlated> retval;
+ double std_deviation_up_value, std_deviation_down_value;
+ retval.value_ = certain_func(arg.value_);
+ std_deviation_up_value = certain_func(arg.value_ + arg.uncertainty_);
+ std_deviation_down_value = certain_func(arg.value_ - arg.uncertainty_);
+ retval.uncertainty_ = (std_deviation_up_value - std_deviation_down_value) * 0.5;
+ if (!is_correlated) retval.uncertainty_ = fabs(retval.uncertainty_);
+ return retval;
+ }
+
+ // For testing double argument functions like atan2, pow.
+ friend unc<is_correlated> PropagateUncertaintiesBySlope
+ (
+ double (*certain_func)(double, double), // for example atan2 or pow
+ const unc<is_correlated>& arg1, // For example arg1 is number to be raised to
+ const unc<is_correlated>& arg2) // arg2 power.
+ {
+ unc<is_correlated> retval;
+
+ retval.value_ = certain_func(arg1.value_, arg2.value_);
+ if (is_correlated)
+ {
+ double up_val = certain_func(arg1.value_ + arg1.uncertainty_,
+ arg2.value_ + arg2.uncertainty_);
+ double down_val = certain_func(arg1.value_ - arg1.uncertainty_,
+ arg2.value_ - arg2.uncertainty_);
+ retval.uncertainty_ = 0.5 * (up_val - down_val);
+ }
+ else
+ {
+ double up_val1 = certain_func(arg1.value_ + arg1.uncertainty_,
+ arg2.value_);
+ double down_val1 = certain_func(arg1.value_ - arg1.uncertainty_,
+ arg2.value_);
+ double up_val2 = certain_func(arg1.value_,
+ arg2.value_ + arg2.uncertainty_);
+ double down_val2 = certain_func(arg1.value_,
+ arg2.value_ - arg2.uncertainty_);
+ retval.uncertainty_ = 0.5 * sqrtSumSqrs(up_val1 - down_val1,
+ up_val2 - down_val2);
+ }
+ return retval;
+ }
+
+ // Predicate Comparison functions.
+ // Should be global to allow leftmost argument to use implicit type conversion
+ // according to Scott Meyers, Effective C++ Item 19 p 68 - 71.
+ // But these are member functions and seem to work OK.
+ // Note MUST be static bool.
+
+ static bool lessU(const unc<is_correlated>& l, const unc<is_correlated>& r)
+ { // less using Comparison criterion including ONE standard deviation.
+ // (Comparison is possibly different for correlated case but not implemented yet).
+ double lhi = (l.value_ + l.uncertainty_); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_); // Lower confidence limit of right.
+ double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ // diff = lhi - rlo;
+ double tol = hypot(l.uncertainty_, r.uncertainty_); // 'Average' of two uncertainties.
+ bool isLess = lhi < (rlo + hypot(l.uncertainty_, r.uncertainty_)); // == less
+ if (true)
+ { // Output diagnostic info.
+ std::cerr << "lessU " << l.value_ << space
+ << lhi // (l.value_ + l.uncertainty_)
+ << space << ((isLess) ? " < " : " >= ")
+ // << (r.value_ - r.uncertainty_) == rlo
+ << space << rlo << space << rlo + hypot(l.uncertainty_, r.uncertainty_) // tol
+ << space << r.value_
+ << space << tol
+ << space << diff
+ << std::endl;
+ }
+ return isLess;
+ } // bool lessU(const unc<is_correlated>& l, const unc<is_correlated>& r)
+
+
+ static bool lessU2(const unc<is_correlated>& l, const unc<is_correlated>& r)
+ { // less using Comparison criterion including TWO standard deviations.
+ // (Comparison is possibly different for correlated case but not implemented yet).
+ double lhi = (l.value_ + l.uncertainty_ + l.uncertainty_ ); // Upper confidence limit of left.
+ double rlo = (r.value_ - r.uncertainty_ - r.uncertainty_); // Lower confidence limit of right.
+ // double diff = (l.value_ + l.uncertainty_) - (r.value_ - r.uncertainty_);
+ double diff = lhi - rlo;
+ double tol = hypot(l.uncertainty_ + l.uncertainty_, r.uncertainty_ + r.uncertainty_); // 'Average' of two uncertainties.
+ bool isLess = lhi < (rlo + hypot(l.uncertainty_+ l.uncertainty_, r.uncertainty_ + r.uncertainty_)); // == less
+ if (true)
+ { // Output diagnostic info.
+ std::cerr << "lessU " << l.value_ << space
+ << lhi // (l.value_ + l.uncertainty_ * 2)
+ << space << ((isLess) ? " < " : " >= ")
+ // << (r.value_ - r.uncertainty_ * 2) == rlo
+ << space << rlo << space << rlo + tol
+ << space << r.value_
+ << space << tol
+ << space << diff
+ << std::endl;
+ }
+ return isLess;
+ } // bool lessU2(const unc<is_correlated>& l, const unc<is_correlated>& r)
+
+ static bool moreU(const unc<is_correlated>& l, const unc<is_correlated>& r)
+ { // less using Comparison criterion within ONE standard deviation.
+ // Comparison is possibly different for correlated case but not implemented yet.
+ return l.value_ - l.uncertainty_ > r.value_ + r.uncertainty_; // Values with uncertainty.
+ } // bool moreU
+
+ static bool equalU(const unc<is_correlated>& l, const unc<is_correlated>& r)
+ { // less using Comparison criterion outside ONE standard deviation.
+ // Comparison is possibly different for correlated case but not implemented yet.
+ return !((l.value_ - l.uncertainty_ > r.value_ + r.uncertainty_) // >
+ || (l.value_ + l.uncertainty_ < r.value_ - r.uncertainty_)); // <
+ } // bool equalU
+
+ static bool equalU2(const unc<is_correlated>& l, const unc<is_correlated>& r)
+ { // less using Comparison criterion outside TWO standard deviations.
+ // Comparison is possibly different for correlated case but not implemented yet.
+ return !((l.value_ - l.uncertainty_ - l.uncertainty_> r.value_ + r.uncertainty_ + r.uncertainty_) // >
+ || (l.value_ + l.uncertainty_ + l.uncertainty_ < r.value_ - r.uncertainty_ - r.uncertainty_)); // <
+ } // bool equalU2
+
+
+}; // class unc<is_correlated>
+
+template <bool correlated>
+std::ostream& operator<< (std::ostream& os, const std::pair< unc<correlated>, unc<correlated> >& u)
+{ /*! Output a pair (X and Y) of uncertain values with (if defined) uncertainty and degrees of freedom.
+ \details For example: "1.23 +/- 0.01 (13), 3.45 +/- 0.06 (78)".
+ */
+ os << u.first << ", " << u.second;
+ return os;
+} // std::ostream& operator<< (ostream& os, const pair<unc<correlated>, unc<correlated> >& u)
+
+
+//template std::ostream& operator<< (std::ostream& os, const std::pair< unc<false>, unc<false> >& u);
+
+//! Two helper functions to provide values and uncertainties as pairs.
+//! \note Names value_of and plural valueS_of.
+
+/*! Allow value part of variables of class unc to be assigned to, and compared with double.
+\tparam T Built-in floating-point type, float, double or long double, or uncertain type unc.
+*/
+template <class T>
+double value_of(T);
+
+/*! Allow uncertainty (standard deviation) part of variables of class unc to be assigned to, and compared with float.
+\tparam T Built-in floating-point type, float, double or long double, or uncertain type unc.
+*/
+template <class T>
+double unc_of(T);
+
+// Pairs
+template <class T> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<T, T>);
+
+template <class T1, class T2> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> values_of(std::pair<T1, T2>);
+
+template <class T> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> uncs_of(std::pair<T, T>);
+
+template <class T1, class T2> //! \tparam T Built-in floating-point type, float, double, long double or unc or Meas.
+std::pair<double, double> uncs_of(std::pair<T1, T2>);
+
+/* already defined.
+template <class T> //! \tparam T Builtin-floating point type or unc.
+std::pair<double, double> values_of(std::pair<T, T> up)
+{ //! \return values (parts) as a pair of doubles.
+ //! \note so can write
+ //! @c std::pair<const double, double> minmax = value_of(*result.first); // x min & max
+ //! whether T is double or unc, or ...
+
+ double vp1 = up.first.value();
+ double vp2 = up.second.value();
+ std::pair<double, double> minmax = std::make_pair(up.first.value(), up.second.value());
+ return minmax;
+}
+*/// Global Predicates compare LessThan or operator< now static member functions.
+// was bool lessUnc(const unc<false>& a, const unc<false>& b);
+
+namespace std
+{ // Fudge until MSVC becomes compliant.
+ template<typename Type> inline
+ Type abs(const Type& a)
+ { // Should be std::abs but is NOT in cstdlib - only provides global ::abs.
+ return Type((a < Type(0)) ? -a : a);
+ }
+} // namespace std
+
+// Predicate compare operators for use by sort etc.
+// Functors are _preferred_ to functions for STL algorithms.
+// Scott Meyers, ESTL, item 46, page 201..
+
+template<typename Type> // Predicate Functor modelled on STL less in functional.
+// Used below by min_element, etc.
+struct lessAbs : public std::binary_function<Type, Type, bool>
+{ // Usage: if (lessAbs<Meas>()(lm, hm)) ...
+ bool operator() (const Type& a, const Type& b) const
+ { // Note const to prevent modification - must be pure function.
+ // (Implies operator< for Type must also be const!)
+ return ((a < static_cast<Type>(0)) ? -a : a) < ((b < static_cast<Type>(0)) ? -b : b);
+ // Allows use with both POD like int and double,
+ // and other types for which both operator< and operator- are defined.
+ // Instead of:
+ // return fabs(a) < fabs(b); // fabs allows use with int and double,
+ // at price of conversion to double.
+ // But will fail for other types,
+ // so abs function written here using only operator< and operator-.
+ }
+
+}; // template <bool is_correlated> class unc
+
+// Specialization of autoprefix_norm for UDT boost::units::uncun
+// See /boost-trunk/libs/units/example/measurement.hpp
+// For autoprefix_norm see /boost-trunk/boost/units/io.hpp.
+// This specialization is required to get autoprefix to work with this class.
+
+using boost::units::autoprefix_norm_impl;
+
+autoprefix_norm_impl<unc<false>, true>::type
+autoprefix_norm(const unc<false> & arg)
+{
+ return autoprefix_norm_impl<double, true>::call(arg);
+}
+
+// Destructor Definitions need to go into unc.ipp, not unc.hpp
+// or will fail to link because two versions.
+
+#include <boost/quan/impl/unc.ipp> // Definitions.
+#include <boost/quan/impl/unc_input.ipp> // Definitions.
+// #include <boost/quan/impl/unc_output.ipp> // Definitions.
+
+#endif // UNC_HPP

Added: sandbox/SOC/2007/quan/boost/quan/unc_init.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/unc_init.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,57 @@
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Copyright Paul A. Bristow 1998, 2012.
+
+/*!
+ \file
+ \brief Initialisation of std::stream iword to store uncertainty information.
+ \details This sets the index values for data stored using the xalloc mechanism.
+ This is included from unc.hpp and accessed from unc.ipp for many functions.
+ Function setUncdefaults is used to set default values for these items for an iostream.
+*/
+
+#ifndef UNC_INIT
+#define UNC_INIT
+
+// unc_init.hpp called by unc.hpp
+
+#include <ios> // for ios_base.
+
+// This block of definitions MUST be positioned before main.
+// 14 indexes of long iwords allocated by calls of ios_base.xalloc();
+// 1st call of xalloc() returns 0 so ios_base.iword(0) used for magic id,
+// 2nd call of xalloc() returns 1 so ios_base.iword(1) used for uncFlags,
+// 3rd calls returns 2, so iosword(2) used for sigDigits ...
+// Order of assignment must ensure these match enum uncindex (if used).
+const long zeroIndex = std::ios_base::xalloc(); // 1st iword[0] to hold a 'magic' id.
+
+const long uncFlagsIndex = std::ios_base::xalloc(); // long& uncFlags = iword(1)
+const long oldUncFlagsIndex = std::ios_base::xalloc(); // long& olduncFlags = iword(2)
+const long sigDigitsIndex = std::ios_base::xalloc(); // sigDigits = iword(3)
+const long oldSigDigitsIndex = std::ios_base::xalloc(); // oldsigDigits = iword(4)
+const long setSigDigitsIndex = std::ios_base::xalloc(); // setsigDigits = iword(5)
+const long uncSigDigitsIndex = std::ios_base::xalloc(); // setUncSigDigitsIndex = iword(6)
+const long setUncSigDigitsIndex = std::ios_base::xalloc(); // setUncSigDigitsIndex = iword(7)
+const long oldUncSigDigitsIndex = std::ios_base::xalloc(); // oldUncSigDigitsIndex = iword(8)
+const long scaleIndex = std::ios_base::xalloc(); // scale = iword(9)
+const long oldScaleIndex = std::ios_base::xalloc(); // oldScale = iword(10)
+const long setScaleIndex = std::ios_base::xalloc(); // setScale = iword(11)
+const long uncWidthIndex = std::ios_base::xalloc(); // uncWidth = iword(12)
+const long oldUncWidthIndex = std::ios_base::xalloc(); // oldUncwidth = iword(13)
+const long oldUncSetWidthIndex = std::ios_base::xalloc(); // oldUncSetWidth = iword(14)
+const long usedIndex = std::ios_base::xalloc(); // used = iword(15)
+const long oldUncUsedIndex = std::ios_base::xalloc(); // oldUsed = iword(16)
+const long widthIndex = std::ios_base::xalloc(); // width = iword(17)
+const long oldWidthIndex = std::ios_base::xalloc(); // oldWidth = iword(18)
+const long roundingLossIndex = std::ios_base::xalloc(); // roundingLoss = iword(19)
+const long confidenceIndex = std::ios_base::xalloc(); // roundingLoss = iword(20)
+
+const long topIndex = std::ios_base::xalloc(); // long& topIndex = iword(21] == iword(0] check!
+
+extern const long indexID; // 'Magic' value defined in unc_init.hpp.
+bool isIndexed = true; // Above indexes have been initialised.
+
+#endif

Added: sandbox/SOC/2007/quan/boost/quan/uncbools.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/uncbools.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,33 @@
+ long& uncWidth = os.iword(uncWidthIndex); //
+ long& oldUncWidth = os.iword(oldUncWidthIndex); //
+ long& uncFlags = os.iword(uncFlagsIndex);
+ long& Width = os.iword(widthIndex);
+ long& oldWidth = os.iword(oldWidthIndex);
+ long& setSigDigits = os.iword(setSigDigitsIndex);
+ long& setStdDevSigDigits = os.iword(stdDevSigDigitsIndex);
+
+ // bools showing output requirements.
+ bool isNoisyDigit; // Extra 'noisy' guard digit to reduce risk of information loss.
+ bool isPlusMinus;// Uncertainty as +/- is required too (but ignore if exact or integer).
+ bool isSetScale; // Defined to mean scale to specified power of 10.
+ bool isAutoScale; // is to scale automatically to SI multple of 1000.
+ bool isUppercase; // Exponential format is, for example, 1E6 else 1e6.
+ bool isExpFormat; // Taken to mean that exponential format wanted (always possible).
+ bool isShowPoint; // Means decimal point is always shown, for example 900. even if not needed.
+ bool isShowPos; // Show + sign always.
+ bool isFixed; // Taken to mean that d.dddd format wanted, if possible.
+ bool isLeftJustify; // left justify, trailing pad after.
+ bool isRightJustify; // right justify, leading pad before.
+ bool isInternalJustify; // Not defined yet, but use to center in field?
+ // bools showing state of arguments value, stdDev, df.
+ bool isExactValue; // value is exact (integer, rational, zero stdDev or noplus & nominus).
+ bool isIntegerValue; // value is an integer, or stdDev = 0.f.
+ bool isUncKnown; // StdDev or uncertainty is valid.
+ bool isValueNaN; // value is NaN
+ bool isStdDevNaN; // StdDev is NaN
+ bool isValueInfinite; // value is infinity.
+ bool isNegativeValue = false; // Value is negative.
+ bool isZeroValue; // Value is zero.
+ bool isCenter; // Both left and right, so center (on decimal point if possible).
+ bool isFirmFormat; // os << setw(9) has prescribed a width.
+

Added: sandbox/SOC/2007/quan/boost/quan/uncdata.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/uncdata.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,79 @@
+/*!
+\file
+\brief Summary of uncFlagsIndex, unc_types and uncertainflags.
+
+*/
+
+extern const long uncFlagsIndex; // uncertain flags for unc_output
+// by << flex << plusminus ...
+extern const long oldUncFlagsIndex; // Saved previous uncertain flags.
+extern const long sigDigitsIndex; // sigDigits auto calc in unc_output.
+extern const long setSigDigitsIndex; // sigfigs to use if setSigDigits flag set.
+extern const long oldSigDigitsIndex; // Previous value of sigDigitsIndex
+// by << setsigdigits ... Value assigned by << setSigDigits(4) ...
+extern const long stdDevSigDigitsIndex; // Sigfigs to use for +|- output,
+// if setuncsigfigs flag bit set by << setuncsigfigs...// Value set by << setUncSigDigits(3) ...
+extern const long oldStdDevSigDigitsIndex; // Previous value of stdDevSigDigitsIndex.
+extern const long ScaleIndex; // Auto scale factor calculated by unc_output.
+extern const long setScaleIndex; // Use if set scaled flag set by << setscale...
+// Scale value set by << setScale(6) ...
+extern const long oldScaleIndex; // Previous value of ScaleIndex.
+extern const long uncWidthIndex; // width to use by unc_output if
+// firm format uncFlags set by << flexform ...// Value assigned by << setUncWidth(9) ...
+extern const long oldUncWidthIndex; // Previous value of uncWidthIndex.
+extern const long oldUncSetWidthIndex; // Not used yet.
+extern const long usedIndex; // output chars actually used.
+extern const long oldUncUsedIndex; // Previous value of usedIndex.
+extern const long widthIndex; // ios setwidth.
+extern const long oldWidthIndex; // Previous value of ios setwidth.
+
+enum unc_types
+{ // 16 type bits used by unc uncTypes. Bit set = 1 means a positive attribute.
+ VALUE_ZERO = 1 << 0, // Too near zero to allow relsd = sd /mean
+ // A few times std::numeric_limits<float>::min() is a suitable limit?
+ VALUE_INTEGER = 1 << 1, // Exact integer 2,3,4 ... may not be possible to store.
+ VALUE_RATIONAL = 1 << 2, // Integers & Fractions 1/2, 1/3, 2/3, 5/4 ...
+ // so don't need irrational - must be if not rational.
+ // Irrational like pi, e ... representated as accurately as possible.
+ VALUE_NEGATIVE_ONLY = 1 << 3, // Value can ONLY be < 0.. ? or <=0?
+ VALUE_POSITIVE_ONLY = 1 << 4, // Value can ONLY be >=0..
+ UNC_KNOWN = 0x20, // Uncertainty known (but if not value may known OK).
+ UNC_NOPLUS = 0x40, // Uncertainty can only be < value, + = zero.
+ UNC_NOMINUS = 0x80, // Uncertainty can only be > value - = zero.
+ // Integer, Rational or Exact by definition like 25.4 mm per inch,
+ // if unc = 0.0f or both UNC_NOPLUS & UNC_NOMINUS.
+ UNC_QUAN_DECIMAL = 0X100, // Quantised by least significant decimal digit.
+ UNC_QUAN_BINARY = 0X200, // Quantised by least significant binary digit.
+ UNC_EXPLICIT = 0x400, //If bit set = 1, uncertainty implicit from sig digits.
+ // or explicit if +/- or calculated (normal default case, bit = 0).
+ UNC_UNIFORM = 0x800, // Uncertainty has rectangular probability distribution.
+ UNC_TRIANGULAR = 0x1000, // Uncertainty has triangular probability distribution.
+ // If not rectangular or triangular, then normal or Gaussian.
+ // But is triangular & gaussian different in real life?
+ DEG_FREE_EXACT = 0x2000, // Known number of observations -1,
+ // so default zero means 1 observation.
+ // else estimated, for example, using Welch-Satterthwaite.
+ DEG_FREE_KNOWN = 0x4000, // Degrees of freedom defined.
+ SPARE = 0x8000 // This unc_type is spare.
+};
+
+enum uncertainflags
+{ // For control of printing.
+ none, // Default.
+ firm = 1, // bit 0: == 0 == false means flex, or firm == 1 == true.
+ setScaled = 2, // bit 1 Set scaled == 1 or not scaled == 0.
+ // by fixed factor SetScale and << scale ...
+ // power10 in range -max to +max.
+ autoScaled = 4, // bit 2: auto = 1 with << autoscale ...
+ plusMinus = 8, // bit 3 = 1 means add +/- uncertainty << plusminus ...
+ addSISymbol = 0x10, // bit 4 = 1, add suffix SI symbol G, M, k, m, u, n, p ...
+ // If one is applicable, else = 0 do nothing.
+ addSIPrefix = 0x20, // bit 5 = 1, add suffix SI prefix Giga, Mega, kilo ...
+ noisyDigit = 0x40, // Add extra 'noisy' decimal digit to value & sd
+ // This means is suitable for input to other calculations because the
+ // random extra 2 to 3 bits will approximate a continuous function.
+ // Quantisation to fewer digits would distort statistical calculations.
+ // Default is to use minimum decimal digits for clearer display.
+ // Extra digit also added when degrees of freedom > 10.
+ setSigFig = 0x80, // if bit 7 = 1 use set sigfig else calculate from sd.
+ setUncSigFig = 0x100 // if bit 8 = 1 use set Unc sigfig else calculate from degrees of freedom.
\ No newline at end of file

Added: sandbox/SOC/2007/quan/boost/quan/uncs.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/uncs.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,122 @@
+// unc reference info from unc.hpp
+
+enum unc_types
+{ // 16 type bits used by UReal uncTypes. Bit set = 1 means a positive attribute.
+ VALUE_ZERO = 1 << 0, // Too near zero to allow relsd = sd /mean
+ // A few times std::numeric_limits<float>::min() is a suitable limit?
+ VALUE_INTEGER = 1 << 1, // Exact integer 2,3,4 ... may not be possible to store.
+ VALUE_RATIONAL = 1 << 2, // Integers & Fractions 1/2, 1/3, 2/3, 5/4 ...
+ // so don't need irrational - must be if not rational.
+ // Irrational like pi, e ... representated as accurately as possible.
+ VALUE_NEGATIVE_ONLY = 1 << 3, // Value can ONLY be < 0.. ? or <=0?
+ VALUE_POSITIVE_ONLY = 1 << 4, // Value can ONLY be >=0..
+ UNC_KNOWN = 0x20, // Uncertainty known (but if not value may known OK).
+ UNC_NOPLUS = 0x40, // Uncertainty can only be < value, + = zero.
+ UNC_NOMINUS = 0x80, // Uncertainty can only be > value - = zero.
+ // Integer, Rational or Exact by definition like 25.4 mm per inch,
+ // if unc = 0.0f or both UNC_NOPLUS & UNC_NOMINUS.
+ UNC_QUAN_DECIMAL = 0X100, // Quantised by least significant decimal digit.
+ UNC_QUAN_BINARY = 0X200, // Quantised by least significant binary digit.
+ UNC_EXPLICIT = 0x400, //If bit set = 1, uncertainty implicit from sig digits.
+ // or explicit if +/- or calculated (normal default case, bit = 0).
+ UNC_RECTANGULAR = 0x800, // Uncertainty has rectangular probability distribution.
+ UNC_TRIANGULAR = 0x1000, // Uncertainty has triangular probability distribution.
+ // If not rectangular or triangular, then normal or Gaussian.
+ // But is triangular & gaussian different in real life?
+ DEG_FREE_EXACT = 0x2000, // Known number of observations -1,
+ // so default zero means 1 observation.
+ // else estimated, for example, using Welch-Satterthwaite.
+ DEG_FREE_KNOWN = 0x4000, // Degrees of freedom defined.
+ SPARE = 0x8000 // This unc_type is spare.
+};
+
+const unsigned short int VALUE_EXACT = (UNC_NOMINUS | UNC_NOPLUS); // Both set.
+const unsigned short int UNC_DEF = (UNC_KNOWN | UNC_NOMINUS | UNC_NOPLUS |
+ UNC_QUAN_DECIMAL | UNC_QUAN_BINARY |
+ UNC_EXPLICIT | UNC_RECTANGULAR | UNC_TRIANGULAR); //
+const unsigned short int DEG_FREE_DEF = (DEG_FREE_EXACT | DEG_FREE_KNOWN);
+
+enum uncertainflags
+{ // For control of printing.
+ none, // Default.
+ firm = 1, // bit 0: == 0 == false means flex, or firm == 1 == true.
+ setScaled = 2, // bit 1 Set scaled == 1 or not scaled == 0.
+ // by fixed factor SetScale and << scale ...
+ // power10 in range -max to +max.
+ autoScaled = 4, // bit 2: auto = 1 with << autoscale ...
+ plusMinus = 8, // bit 3 = 1 means add +/- uncertainty << plusminus ...
+ addSISymbol = 0x10, // bit 4 = 1, add suffix SI symbol G, M, k, m, u, n, p ...
+ // If one is applicable, else = 0 do nothing.
+ addSIPrefix = 0x20, // bit 5 = 1, add suffix SI prefix Giga, Mega, kilo ...
+ noisyDigit = 0x40, // Add extra 'noisy' decimal digit to value & sd
+ // This means is suitable for input to other calculations because the
+ // random extra 2 to 3 bits will approximate a continuous function.
+ // Quantisation to fewer digits would distort statistical calculations.
+ // Default is to use minimum decimal digits for clearer display.
+ // Extra digit also added when degrees of freedom > 10.
+ setSigFig = 0x80, // if bit 7 = 1 use set sigfig else calculate from sd.
+ setUncSigFig = 0x100 // if bit 8 = 1 use set Unc sigfig
+ // else calculate from degrees of freedom.
+};
+
+void uncertainPrint( // Declaration, defined below.
+ double, // Mean or most likely value.
+ float, // Standard deviation.
+ unsigned short int, // Degrees of freedom.
+ unsigned short int, // 16 Uncertain type flags.
+ ostream&); // Output stream.
+
+
+void uncertainRead(double& mean, // mean (central or most probable) value.
+ double& stdDeviation,
+ unsigned short int& degreesOfFreedom, // 1 observation.
+ unsigned short int& types,
+ istream& is);
+
+// Parameterless Manipulators declarations.
+// Similar to ios_base flags but for uncertain printing.
+// Use uppercase convention for these,
+// but all lowercase for manipulators like hex, oct ...
+// Usage: out << scale << noscale << autoscale << noautoscale
+// firmform << flexform << plusminus << noplusminus ....
+
+// All ios_base functions declared below are defined in unc.cpp
+// Note that all of these are entirely lower case, like ios manipulators.
+ios_base& scale(ios_base&); // To use value set with setUncScale(int)
+ios_base& noscale(ios_base&); // or not scaled.
+ios_base& autoscale(ios_base&); // Scale to suitable symbol like M, k, m...
+ios_base& noautoscale(ios_base&); // or not.
+ios_base& firmform(ios_base&); // Firm fixed layout using setUncWidth.
+ios_base& flexform(ios_base&); // Flexible free format.
+ios_base& plusminus(ios_base&); // Add +/- uncertainty.
+ios_base& noplusminus(ios_base&); // No +/- uncertainty
+ios_base& addSIprefix(ios_base&); // Add SI prefix like kilo, micro ..
+ios_base& noSIprefix(ios_base&); // (Takes precedence over SI symbol if both set).
+ios_base& addSIsymbol(ios_base&); // Add SI symbol like M, k, m.
+ios_base& noSIsymbol(ios_base&); // No SI symbol like M, k, m
+ios_base& addNoisyDigit(ios_base&); // Add an extra 'noisy' digit for computer.
+ios_base& noNoisyDigit(ios_base&); // No noisy for human reading.
+ios_base& setsigdigits(ios_base&); // Use sigDigits set with << setSigDigits(4) ...
+ios_base& autouncsigfigs(ios_base&); // Calculate sigfigs from uncertainty.
+ios_base& setuncsigfigs(ios_base&); // Use sigDigits set with << setUncSigDigits(2) ...
+ios_base& autosigfigs(ios_base&); // Calculate sigfigs from uncertainty.
+
+// Functions to change uncertain flags on specified ios_base.
+// Usage: f = uFlags(out); f = uFlags(out, 0xFF);
+// f = setuFlags(out, 0xFF); f = resetuFlags(out, 0xFF);
+long uFlags(ios_base&); // Returns current uncertain flags.
+long uFlags(ios_base&, long); // Assigns all uncertain flags & returns previous.
+long setuFlags(ios_base&, long); // Set specific flags = 1
+long resetuFlags(ios_base&, long); // Reset/clear specific flags = 0
+
+// Forward declarations, defined in unc.cpp.
+class showUncFlags; // Output uncertain flags to ostream << showUncFlags ...
+class setAllUncFlags; // Assign value to set (aand/or clear) all unc flags.
+class setUncFlags; // Set specific unc flags bits.
+class setMaskedUncFlags; // Clear mask & then set unc flag bits.
+class resetUncFlags; //
+class resetMaskedUncFlags;
+class setUncWidth;
+class setUncScale; //
+class setSigDigits; // sigfigs to use for value if << setsigdigits
+class setUncSigDigits; // sigfigs to use for uncertainty if << setuncsigfigs
\ No newline at end of file

Added: sandbox/SOC/2007/quan/boost/quan/xiostream.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/boost/quan/xiostream.hpp 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,120 @@
+/*! \file xiostream.hpp
+ \brief Extra iostream manipulators
+ \details Definitions in xiostream.cpp
+
+ \author Paul A. Bristow
+ \date Sep 2009
+*/
+
+// Copyright Paul A. Bristow 2009
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef XIOSTREAM_HPP
+#define XIOSTREAM_HPP
+
+#include <iostream>
+#include <cfloat> // for <float.h> for _isnan, _finite, _fpclass & values.
+
+//using std::ios_base;
+//using std::ostream;
+//using std::istream;
+//using std::cout;
+//using std::cerr;
+//using std::endl;
+//using std::hex;
+//using std::dec;
+//using std::showbase;
+//using std::ios_base::fmtflags;
+//using std::ios_base::iostate;
+
+// Parameterless ostream manipulators space, newline, bell, etc.
+// Usage: out << bell << newline << tab << space << twobackslash ...
+// Now done more simply using:
+const char nl = '\n';
+const char tab = '\t';
+const char space = ' ';
+const char sp = ' ';
+const char bell = '\a';
+
+// Single int parameter manipulators.
+// Usage: out << spaces(12) << stars(8) << tabs(2) ...
+// spaces & stars done with simple way, NOT using template,
+// See S Teale p 181-3, said to be longer but faster.
+
+// TODO these should be declared here, and *defined* elsewhere?
+
+class spaces;
+class tabs;
+class stars;
+class chars;
+
+class spaces // Definition for this file.
+{ // Usage: out << spaces(12) ...
+ friend std::ostream& operator<< (std::ostream&, const spaces&);
+public:
+ spaces(int); // Constructor defined in xiostream.cpp.
+private:
+ int num;
+};
+
+class tabs // Definition for this file.
+{ // Usage: out << tabs(2) ...
+ friend std::ostream& operator<< (std::ostream&, const tabs&);
+public:
+ tabs(int); // Constructor defined in xiostream.cpp.
+private:
+ int num;
+};
+
+class stars // Definition for this file.
+{ // Usage: out << stars(10) ...
+ friend std::ostream& operator<< (std::ostream&, const stars&);
+public:
+ stars(int); // Constructor defined in xiostream.cpp.
+ // private:
+ int num;
+};
+
+// Manipulator class with int repeat count & character chars.
+class chars // Definition for this file.
+{ // Usage: out << chars(10, '_') ....
+ friend std::ostream& operator<< (std::ostream&, const chars&);
+public:
+ chars(int, char); // Constructor defined in xiostream.cpp.
+private:
+ int num;
+ char character;
+};
+
+class setupperbase
+{
+ friend std::ostream& operator<< (std::ostream&, const setupperbase&);
+ friend std::istream& operator>> (std::istream&, const setupperbase&);
+public:
+ setupperbase(int); // Constructor defined in xiostream.cpp.
+private:
+ int base;
+}; // class setupperbase
+
+void outIosFlags(long flags, std::ostream& os); // Show std iostream flags.
+void outFpClass(double value, std::ostream& os); // Show Floating-point type.
+
+void outIOstates(std::ios_base::iostate rdstate = std::cout.rdstate(), std::ostream& os = std::cerr, const char* term = ". ");
+// Outputs rdstate as words "good", "eof", "fail" and/or "bad".
+void outFmtFlags(std::ios_base::fmtflags fmtFlags = std::cout.flags(), std::ostream& os = std::cerr, const char* term = ". ");
+// Outputs ios_base fmtflags as words like "skipws", "scientific", "left"...
+// Note that the default values must be in the header file, NOT in the .cpp or .ipp file.
+
+// Ostream manipulators to show state of stream.
+std::ostream& showiostate(std::ostream& os); // Show IO stream state in words for this stream.
+// Usage: cout << showiostate ...
+
+std::ostream& showformat(std::ostream& os); // Show IO stream format flags in words for this stream.
+// Usage: cout << showformat ...
+
+#include <boost/quan/impl/xiostream.ipp>
+
+#endif // XIOSTREAM_HPP

Added: sandbox/SOC/2007/quan/libs/quan/doc/doxygen/draft.png
==============================================================================
Binary file. No diff available.

Added: sandbox/SOC/2007/quan/libs/quan/doc/doxygen/draft.svg
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/libs/quan/doc/doxygen/draft.svg 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ version="1.1"
+ width="652"
+ height="694"
+ id="svg2">
+ <metadata
+ id="metadata8">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <defs
+ id="defs6" />
+ <image
+ xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAowAAAK2CAIAAABLsFpKAAAAA3NCSVQICAjb4U/gAAAgAElEQVR4 nO3d23bbuJaFYQA8y066R7//M/boim1RPKIv1g63to+SCIAg+H9XrlRCMXLMqQUsANpaqwAAiM80 TVmWbX0XWzJb3wAAAJ/ouq5t277vt76RLeVb3wAAAO91XXe5XKZpmudZKVWW5dZ3tA0qaQBAXJaE VkqN43i5XA5bT1NJAwAicp3QYhgG+eKA9bSmcQwAEImPCb3I87yqqqqqwt/VhqikAQBR+CahlVLj OCqltNaHqqcJaQDA9r5PaCHj3tba49TThDQAYGO3JLRSSmst9bRS6iA5TUgDALZ0Y0IvDpXThDQA YDP3JrQ4Tk4T0gCAbfR9/0BCi4PkNCENANjAYzX0tSPkNCENAAhtTQ19bdnnJNWcJqQBAEH1fd+2 7fqEVgfo92bvbgBAOA4TejEMwzAMS1qnhJAGAITjPKGVUnmeG2OSPHmakAYABPLPP/84T+gsy4qi aJpGa+32yjEgpAEAIZDQDyCkAQDekdCPIaQBAH6R0A8jpAEAHpHQaxDSAABfSOiVCGkAgBc+EtoY c5yEVuw4BgDwgRraCUIaAODY//3f/83z7PaaB0xoxXA3AMCtf/75h4R2hZAGADjDPLRbDHcDANxg Hto5KmkAgAMktA+ENABgLRLaE0IaALAKCe0PIQ0AeBydYl7ROAYAeBA1tG9U0gCAR5DQARDSAIC7 kdBhENIAgPswDx0Mc9IAgDv4q6Hruiah3yGkAQC3YpQ7MIa7AQA3oYYOj5AGAPzMa0IbQxh9jvcF APADf51iJPT3eGsAAN/xlNBlWZLQP+LdAQB8iYTeFm8QAOBzJPTmeI8AAJ8goWPA2wQAeI+EjgTv FADgP5DQ8eDNAgD8GwkdFd4vAMC//Pnzh4SOCnt3AwCUooaOEu8aAIAaOlK
8cQBwdH/+/BnH0e01 SWgneO8A4NBI6JgxJw0Ax8U8dOR4BwHgoEjo+PEmAsAR0Sm2C7yPAHA4PuahlVLTNBVFQUI7xFsJ AMfyzz//+EhopZTW+vX11dPFj4mQBoAD8TEPfc1a+/LyQk67QkgDwFH4mIf+iJx2iJAGgEPwNA/9 KXLaFUIaANIXMqEFOe2EttZufQ8AAI98z0N/Q2v969evPGfjrAdRSQNAysLMQ3+FenolKmkASNaG NfQ16umHUUkDQJq2raGvUU8/jJAGgASF7xT7Hjn9GEIaAFITW0ILcvoBzEkDQFIimYf+CvPTd6GS BoB0RJ7Qinr6ToQ0ACQink6x70lOD8Ow9Y3sACENACnwd7aVD9Zazsu6BSENALu3lxr6GvX0LWgc A4B989HLbYwpikIpNY6j1/jXWj8/P8tr4SNCGgB2zF9CN02jtb5cLn3f+y7Tf/36RU5/iuFuANgr rwltjNFa13VdlmWWZW5f5Z3X11fGvT9FSAPALvlOaPmVMDktfWTk9EeENADsj4+E1lq/S+jl18np rRDSALAznhK6LMuPCb3837qui6IgpwOjcQwA9iR8Qi+stQH6yOj3vkZIA8BuhJmH/kaYnFb0e//F cDcA7EPIeehvfn+AcW+lFPucCCppANiBzWvoa4x7B0MlDQCxiyqhFX1kARHSABC1GEa5P71C0zRF UTx8hVuQ0wx3A0C8NuzlvgV9ZL4R0gAQqdhGuT9FTnvFcDcAxGgXCa1C7UemjtrvTSUNANH5559/ nBemPhJ6QT3tCZU0AMRldwmtruppr31k6nj1NCENABH58+fP7hJaSE5XVcW4t0OENADEYi/z0F9h fto5QhoAorD3hBbktFuENABsL42EFuS0Q4Q0AGwspYQW5LQrhDQAbCm9hBbBcvrPnz8J5zTrpAFg M6km9IL10ytt/y0EgGOK8+QMtzh/eiUqaQDYQPI19DWpp7uum+fZ6wulV0/H9Y0EgCN4eXk5TkKr gPuc
pDc/Hd33EgDSNs+z8+0zY05oEaaPTGud2Lh3pN9OAEiVMSbP86ZptNauLhh5QgvWZT2AOWkA 2MA0TeM4tm27cpp2Lwm9oN/7Lvv4pgJAYrIsy/O8rus14bq7hFbU03eikgaAzaypp/eY0Avq6Rvt 71sLAMl4uJ6ObT30vainb0QlDQAbu7eelhq6rmvfCecb9fSPdvkRDABSIvX0jWXxMsq994RW7O99 A0IaALa35PT367J2PQ/9qSWnvf6N9rt+muFuAIjFNE3DMFwul0/HvdNL6Gtt2/oe97bW/v79e1/j 3oQ0AETkq/npZOahvxEgp9Xe5qcT/DgGABtauTnJp/3eR0hopVTTNPR7v0MlDQDOvL6+yiTryqS5 rqcPktAL6ulrhDQAuCGnT7rKVMnpruuyLDtOQgtyekFIA4AD1+dDu8rpeZ6nacqyLMlOse+R04KQ BoC1rhNauMppa62rw7J2h5xWhDQArPQxocXR5pJ9IKcPN4QCAA59ldBKqXmeZdGz74xJGP3ehDQA POibhBbk9HqS075n5aPNaUIaAB7xY0ILcnq9pmmqqjrm/t7MSQPA3W5M6AXz0+uFmZ9+fn4uy9Lr S9yFShoA7vPy8nJXQivqaRfCzE+/vr72fe/1Je5CSAPAHR6evCSn1wszPx1VThPSAHCrle1F5PR6 Mj8doI8skpxmThoAbuKqAVhrXZYl89NrHGd+mkoaAH7msPXXWks9vdJx5qcJaQD4wQOdYt+b53kc x3EcGct82EFympAGgO/42OZCa53neZ7nh92X24kj9JExJw0AX/KR0KyZdqtt267r5nn2+ipbzU9T SQPA50joXQizH9lW/d6ENAB8goTekQDz01rrTXKa4W4AeI+E3qMk12VRSQPAfyChdyrJfm8qaQD4 t3tPzrgFCR1SYvU0lTQA/Ivz9dCKhA4usXVZVNIAoBSj3GlJpp6mkgYAXzuWkNBbSaaeppIGcHTU 0KlKoJ6mkgZwaJ4SOs9zEnpzCf
R7U0kDOC5q6CPYdT1NJQ3goEjog9j1/DSVNIAjYj300ey0nqaS BnA4rIc+oJ3OTxPSAI6FUe7D2mNOE9IADoSEPrjd5TQhDeAoSGioveU0IQ3gEFgPjUXTNFVV7SKn CWkA6fO062ee503TkNB7VNf1LnKakAaQOH+j3CT0rtV1Hf+4NyENIGX+RrlJ6ATEPz9NSANIFqPc +FHk89OENIA0+Tt9koROTMzz02wLCiBBnnb9pIZO2OVy6boutn1DqaQBpMbTrp8kdNrirKcJaQBJ oVMMD4swpwlpAOmgUwwrxZbThDSARLAeGk5EtX6axjEAKWCUG25F0kdGJQ1g90hoOBfJuDchDWDf SGh4EkNOE9IAdoyEhlebz08T0gD2ioRGANvu703jGIBdYk8xhLRVHxmVNID98bGnGOuh8Y2t5qcJ aQA7w8kZ2MQmOU1IA9gTEhobCp/ThDSA3WBPMWwuWE7LP3VCGsA+sC83IhEgp/M8t9Zaa3N/rwEA rrDaClGp61op5anfuyiKqqqKotBaU0kDiB0JjQh5qqevE1ox3A0gciQ0ouV8P7J3Ca3YzARAzEho xM/VPicfE1pRSQOIFgmNXXAy7v1pQitCGkCcSGjsyMqc/iqhFSENIEIk9BrTNDl/9/Cjh3P6m4RW SrEEC0BcSOg1xnEchmEYhnEcm6bZ+naO5YF1Wd8ntCKkAUSFhF5DErptW6XUPM9KKXI6sLty+seE Vgx3A4gHCb3GdUIrpeZ57rpu+U8Ec+O49y0JraikAUSChF7jXUILyWlFPR2c1NN93391oOqNCa0I aQAxIKHX+DShxTzPcp4SOR2Y5LRS6mNO357QipAGsDkSeo1vElpM00ROb+LTnL4roRUhDWBb/hK6 rmsSWkzTxLj3Jt7l9L0JrQhpABuihl7jxoQWjHtvZclprfW9Ca3YuxvAVkjoNe5K6EWWZWVZktPh 9X0vh5ffldCKkAawCa+j3Hme+BjhYwktyOmtWGvvTWjFOmkA
4ZHQa0hCn8/nx/649JGxfjq8BxJa UUkDCMxHQmuti6I4TkKvj1hjTFVV1NPxo5IGEA4JvcY4jn3fP1xDX5M+Murp+BHSAAIhodeQGvpy uTw2avoR4967QEgDCIGEXsPVKPc70zRN0/TV1pWIASENwDtPCX2oTjEfJW+e50VRJP8G7hohDcAv fzV00zTJB8zKXu5v5HleVVVVVc6vDIfo7gbgEaPca3itoUnoXaCSBuALo9xrUENDEdIAPHl9fXWe 0Eop2fXzOAntqpdbWGtJ6H0hpAG49/r6Ksc5ODfPszGJP7iWUW4SGsxJA3DMX0KLLMt+/fqValR7 moe21so5iST0vqT5rxzAVuZ51lp7TdBpml5eXuZ59vcSW/HXKUZC7xQhDcAlY0xd10VRkNP3opcb HxHSABzLsoycvhcJjU8R0gDcI6fvQkLjK4Q0AC+WnHbbovxOAjktZ1uR0PgUIQ3AF8npsizJ6a8s Z1u5vaystirLkoTeO5ZgAfBrmqbL5TIMg9cc3eO6LEa58aM9/YMGsEfMT3/K33poEjolhDQA78jp d6ZpYscS3ILhbgCBMO4tpmmiUww3ivffMYDEUE8rEhp3IqQBhHPwnCahcS9CGkBQh81pSWjnq60U CZ005qQBbOBo89PU0HjM9v92ARzQoeppamg8jEoawGaOUE/727FEPuiQ0GmjkgawmeT395b10D5q aBL6IKikAWws1Xp6GeV2/phllPs4qKQBbCzJ+WkSGk4Q0gC2l1hOk9BwhZAGEIVkcpqEhkPMSQOI yDzPbdvud36ahIZbhDSAuOw3p2W1FQkNhxjuBhAXY0zTNLsb915OnySh4RAhDSA6u8tpT7t+WmtJ 6IMjpAHEaMnp+Pc58bfrZ1EUJPTBMScNIF7xz0/TKQavCGkAUQuT08aY379/35vTJDR8Y7gbQNTC zE/P83zvuDcJjQAIaQCxi7CPbOkUc57QWZaR0FgQ0gB2wBgTz3lZXs+H5mwrXGNOGsBuBO
sje35+ zrLs0//rdZS7LMu6rt1eFrtGJQ1gN4KNe7++vn76OcBTQltrZZSbhMY7VNIAdkbq6b7vvT6+PtbT nnYsUXSK4WtU0gB2RurpsiwD1NPTNC3/6Smh6RTDN6ikAexSyPlppRQ1NDZBSAPYqzA5rbWuqqrr OjrFEB4hDWDHwsxP+0BC4xbMSQPYsWV+2uv6aedIaNwo3/oGAGAVyWmllO9xb1dIaNyOShrA7oVZ P+0ECY27xP4PGgBusYucJqFxr3j/NQPAXSLPaRIaD4jxnzIAPCbanCah8Zi4/h0DwEoR5jQJjYfF 8o8YAFyJKqdJaKyx/b9gAHBuyelt10+T0FiJddIA0rT5+mkSGutRSQNI1ob1NAkNJwhpACnbZN9Q EhquENIAEhc4p0loOMScNID0hZyfzvOchIYrVNIADiHYuqy+76dp8voSOA5CGsBRhMnpeZ5fXl7I aThBSAM4kDD93uQ0XNHW2q3vAQCCmue5bVvf89PGmF+/fmVZ5u8lkDwqaQCHw7g39oKQBnBE5DR2 geFuAMc1z/Plcun7nnFvxIlKGsBxGWPqui7LknoacSKkARzaktP0eyNCDHcDAOPeiBSVNAAw7o1I EdIAoBQ5jSgR0kBcxnH0fQIEvkJOIzbMSQMReX197fu+LEs57lAp5fs0CHwUZn5aa/3792/mp/E9 QhqIhST08p95nmdZVlWVMYaoDow+MkSCkAai8C6hr1VVlee5nAnhdZkQrpHTiAEhDWzvm4RWSllr tdZFUeR5XlUVUR0M497YHCENbOz7hBaS00JmrH0ftghBPY1tEdLAlm5J6E/RXBYMOY0NEdLAZh5O aKG1NsaUZVkURZZlFNb+MO6NrRDSwDZWJvQ1a23TNFmWSWFNWvtATmMThDSwAYcJvTDGyKotOSuC MXDnGPdGeIQ0EJqPhF5IGV3XdZZlRVEoCmunyGkERkgDQb29vXVdF+a1ZIE1Y+BukdMIiZAGwgmZ 0LJqyxijtZbCmuY
yV8hpBENIA4GETOhPSVRTWDtBTiMMQhoIYfOEXgrrPM9lLxQpsje8pb2j3xsB ENKAd5sn9Duyc5kU1nmeKwrrR1FPwzdCGvArtoQWS2EtO5flec6W4I8hp+EVIQ14FGdCv/OusCaq 7xUsp5+fn2XkA8dBSAO+7CKhr0lb2dJchtuR0/CEkAa8GMfx7e1tmqatb+Ruxpgsy6qqyrKM5rLb kdPwgZAGvLDWys5iOw05rbVEtTSEK5rLbkBOwzlCGvBlHMeXl5e9/4jJLijSX0Zz2Y/IabhFSAO+ TNPUtm3XdQkEm4x7N00jg+EJ/I38IafhECENeNR13dvb22N/VmtdFEU8GW+tlYSWvVDoA/8GOQ1X CGnAo2mazufzMAwP/FlrbV3XeZ5fLhdrrdfH/b2kp6yua2MMzWWfIqfhBCEN+NW2raTsvX/QWpvn +el0MsYMw9D3/TRN8fzAWmtl3FuiWo7FxDVyGusR0oBf1to/f/48thZLIrCqKq21tbbrumEYxnGU /cKc3+rDZAxcWsFpLrsmOT0Mg9fFeFrrX79+kdNJIqQBv6y1Ukw/fIVfv34tdaqE9GOluVdS90tz mdaawFhQT2MNQhrwbhzHP3/+PPzH8zx/enq63rdZorrrummaIixbl4O2aC4TYeppcjpJhDTgnRTT bds+llhSnpZlaYxZflHKsrZtp2mKbQBcbkYWWMsYOCdDkNN4DCENhND3/dvb28M/bh+LaWGtnaZp GIau66Jq/17I0LdsCX7w8GB+Gg8gpIEQrLVvb2993z98haqqnp6evvq/8ujvui62xVrqb2EtY+DS BHfY5jJyGvcipIEQrLV935/P54d/4owxTdNUVfXNS8zzPPz16J36dX16xzHHwGXug5zGjQhpIJB5 nl9eXsZxfLiILMuyaZrvs81aKx8IZGl1hAWrPHNkAFwK6+u59iOQnPbd701Op4GQBgKR7Hx4l1Bx Op3qur7ld47jOE1ThLuVCXnyFEWxRPWhCmvqa
dyIkAbCWX/ItNb6+fn5xu29JJ5lHlQ6wKNqAl/I LuWyaus4m4xST+MWhDQQlKzFeviPL3uQ3TtELIuq1+yp4tUyBi5T70qpI4yBk9P4ESENBDUMw/l8 XlNMZ1n2/Pz8QMVprZWeMkmFaAtWY8yyaiv5MfAwOa2U+v37Nzm9R4Q0EJS19nw+d1235gplWT4/ Pz+WsssA+DzP4zg+fBteyXNJmsCloT3hwjrM/LQip/eJkAaCknnil5eXNZWT1vp0OpVl+XA1LLch TeDRRrXI8zz55jLqaXyFkAZCk0OmV66PKstSTrF8+ArSRDaO4zzP5/NZ/d1qNE7SXCb9ZUk2l9Hv jU8R0sAG+r5/eXlZmTS3L8f60TRNsmGZNIE7uaYP1zuXqeTGwMlpfERIAxuQYnrlvmBFUTRN4+pp K4W1NIHLlHnMDwdjzHVhvfXtOMP8NN4hpIFtrFyLpZTSWj89PZVl6eqWhLV2HMdxHPu+9x0VK2mt pQlc3oQ00pqcxjVCGtjGPM+vr68rm7aMMb9///YRTrJGS3ZBiXYn8EWWZVJYZ1mWQFSHyek8z2Ut n7+XwHp8jAI2k+f5MAwrZ6b7vpfOZ1d3JeTZXde1rNSSPnC3L+GQzKlfLpe6riWwd33QlpwgLl97 yuksy1w1NMArKmlgM+M4vry8rPwZLIri6enJdyZN0zTPs8xYS/UfcwQWf+26D9zfuqwsy6SbgTI6 foQ0sBmJvfP5vDJImqZZCi9/ZOvvaZr6vpdJ68jzzxhT17W0mKm4P1V8xce4Nwm9Lwx3A5uRw5XX h8cwDHI6hZO7+or+qygKiQ05YivaD/qy/ns5vUNWbe0rqpdxb1dHmZHQu0MlDWzs7e1tzS6hSilr 7fPzs4RQMFJVL03gkT9JZLcyaQXP83xfUe2qniah94iQBrYkh16cz+eVdZKcuhF+10xZXX25XGR1 dZxHYS7k3pYtwSO/22vrc9oYczqdSOjdYbgb2JIMxmZZtjKkZXFz+D4peTl
pAi+KQprAo/3oLzd2 uVy01n3fy1lbWuv4c2tlvzc19H5RSQMbk2L69fV15XXyPP/9+7eTW3rYPM/WWjliS9I65lJV4rks S5nRj/xu1aP1NAm9a4Q0sL1xHF9fX6dp2kWb94+km0x2Au/7XsXdrmWtvY7qyBdY35vTJPTeEdJA FC6XixxFtcb6o7HckiO22rZ11ZzslTTbS3OZk657T27PadmxRNaLh7k3OMecNBAFOTV5Zftu13VF UQRu8/6GbA0tM+5SWMcc1fM8yyj9UliXZRnhGPiN67JI6DRQSQOxcLIWS4rp8G3e35PnjBR/6zdv CUOOxZTtUCLcuez7epqETgaVNBAFa21VVcMwrKk1tdZxHggtCSdnVeV5LtuWRb66Whr6pGdeVm1F 1Vz2Tb+3bLVGQqeBShqIheyQJZ1Wa8Q2M/3R9RFb8XeWKaWstRLSVVVJVR3JDX+sp40xTdOQ0Mmg kgZiIRXb+pCWI6FifkYvR2zJ+PwwDDKEEEnyfaS1liNGZMa6rmtZ4L71fb2vpxnlTg+VNBCRaZra tu26bmVc1XV9Op1c3ZVvMu4t25Z5PUHZIekDz/NcmuO2/Xgh9fQ0TWVZktCJIaSBuDhZi2WMeXp6 iqHUu500V/d933VdzFW1kMlpWawlhfW2zXqylbr0uG14G3CO4W4gLmVZLjO1D5PAi6fL6RYy1yt7 i259Lz+TN1ZKfxkDl+nqrVZtSS964BdFAHxTgbhITab1qlEua+35fJa11w7vzbdxHOX4yx19tlB/ N04fx1EO8ZTtUKho4QQhDcRFa12WpZwoteYiSimp8PYSeMMwyMTqHufg5E2WqF6ay4wxeZ7v7jMH osKcNBAd6QO6XC4rr1MUxfPz8y4SYtcJ/SlrbfGXjGfs4huB2FBJA9FZ5hdXFmHjOHZdV9e1u1vz YhgGWTO99Y24JBvLSHuBHF8te4NvfV/YGSppIEauiumyLJ+enmKu4dKroT8lrQayRCrLMsbAcSMq aSBG
TtrHlFJ935dlKftxRkhq6OQTWv3dZHQYBglpWbVFcxl+RCUNRMpa+/Lysn4QuKqqpmkizIOD 1NCfkqFv2RKcwhrfoJIG4lVV1foMG4Yhwmlp5zW07OOxl4nteZ7llBFZr1VVFYU1PkUlDcRrmqbX 19eVO2XK+VpRzUwvnWIOE7osy7qup2mSXi3Zy8XJxQOIZ+cyxIaQBuJlre37/vX1dWW+Zln2/Pwc ydNfEnoYBlcXXBJaKlE567PrOlmy7OpVfLPWGmOKosjzvCzLeA7awrYIaSBqwzCcz+dxHFc+spum WY5L2pDvhF5Ya+XQKonq+DcDvybndsgpYZF8tMJWCGkgdm9vb13XrbxInuen02nb7Z19JHRRFN+3 xck25m3byjSwq5cOQDYsq+uaTbmPjO89EDtpH1vZEiXHIbu6pQcEq6E//jY5E0yO2JINRlzdg1fy qUJOid7RMADcIqSB2DnZf1t2R8nzfJMW4mW1lasL3pjQ179fa306ncZxlEO7rbWRjyNKK1me5yT0 kRHSQOyMMU3TrO+FlsOaiqII/NB3vh763oQW8rfO/5IVUFKqOrkrt+SIjqIoWJd1cHz7gR2Q3bxX hpyM94ZPaOfroR9I6HeyLJPTR+q6rqpKRXb6RZZlTdOQ0FA0jgF70XXd+rVYWuunp6dgu4RGUkN/ TwYYpmnqui6GqloGTkhoCEIa2Id5nt/e3tY3XtV13TRNgMLR344lPtJLpqil6N9wdbXMQ5PQWBDS wD5IhLRtu/I6Wuvn5+eiKJzc1Vf2ldALiWqZq5Zty0IOg5PQ+IiQBnZjnuc/f/6sXEmltZaJWH9J sNOEviZD9FJYhxkDJ6HxKf41AHsiG0auuYJUiv4KROcJrbUOnNBKqSzLZPuXp6enANuJkND4CpU0 sCfjOL68vKxfi3U6neQ4B1c3JhKood+RQyRlCxQZBnc+Bk5C4xuskwb2xBhTVdXlcllzEUmdeZ7d 7gudRg398R6UUnmey6qteZ5lDN
zV9m0kNL5HSAN7Yoxxkqx93xdF4TCk06uh35FDJI0xz8/PS2fZ ym3LSGj8iJAGdqaqqr7v1y8TGobBVU5vtS93eFJYy0LzoiiWHUYfuNSy62dsf0dEhZAGdsZaK0du rBlx1VrLAY7rNwZfaug1F7kWbUIv5B2Ts5+LohiGQc7EvD2tl4TmJEp8L9KfAQBfkXFXJ71Ll8tl 5eh08qPc35PvRVVVT09Pp9OpLMtb3odlX24SGj+iuxvYH1lG9fb2tvI6WZbJIdOPRf7BE/ojWVQt VfU4jp++q+z6ibsw3A3sj9ZajkmepmlNSS3dT4/tPkZCf5RlmSywVkrJpuXvZgFIaNyLShrYq7Zt 1+8Saox5enq6N6dJ6Fss53bM8yzT/03TMA+Nu1BJA7tkrS2KQtYCrbmOVHt3jXiT0Ddazq6W1dVV VUmpvfV9YU8IaWCXpGUpy7L1O0u3bSuNyrf8ZhL6XssYuLU21b8j/OFfDLBXWuv1h07KH78xdH3s KVYURcIJvZA2gq3vAvvDPxpg35wcOtl13Y+/x9Oun03TkF7AV/jZQNTsf9r6dqKTZZnsfrWSTJp+ 8xtIaGATzEkjIhIAsqzIWjvPs5xBJFtrLR038oXWWn6bv1MXd0EOfli5Jae829KB/PH/+piHLoqC hAZ+REhjS0sGT9MkG3QopZbTACU55At1NatnjJHe5qV5Sl1F+NFIU9L6fbO7rsvzvKqqd79OQgMb Yp00tiEBrJTquk621HisLJZ6WoJKakr1txnqOKy1Ly8vK3fPttbWdV3X9fXHHRIa2BaVNIKSGB6G QTZ5WKJaYvWBcJW56nmeh2GQTbhkZeqhFqRaa/M8l9GIhy+ite77/rqSJqGBzVFJIxyZ9ey6TkLa a71bluUyeHuEwnocx5eXl5U/ztbasiyfnp6MMSQ0EANCGiFIsSsPfRvkC+AAACAASURBVCn4wgRn 8VfyVbW19nK5nM/nlW9slmVPT09yNRIa2BwhDe8kmNu23WQZ
lUxaN02znHyQqr7vX19f138Aknl9 EhqIASENv7qu67puZU/TetJcJttPbnsn/lhrz+fzLduShERCA2ukXFhgQ9ZaOVhXCujNZ4WttXLK r6zdyrJs81vyQdZiSS9eDGTXTxIaeBiVNNyTFc99369fvOuDzFJXVZVeTs/z/Pr6uvm4haCGBtaj koZj1tq2bfu+j6eee0d6y6dpSi8/jDFVVcUQ0iQ04AQ/P3BG+sJeX1/llPutb+c78zxLm5XsPLr1 7bgUwwJxEhpwheFuuCHbicTQI3aXLMtOp5MxZvNgc6ht27Ztt3p1EhpwiJ8iOCA9YrKydut7uc80 TTKJO03T1vfijGy4tslLk9CAW/wgYa1xHM/nc9u2O805mURPKaeLosjzPPwgGQkNOMfPElYZx1EK 6Mgnob83z3NiOV1VVeCdW0howAd+nPC4YRjO5/MwDAl0NiSW07LPWrCXI6EBT/iJwoP6vpfjERNI aJFSTmdZVtd1mG8NO5YA/vBDhUfI+qWt78K9eZ7P53Ma67KyLKuqyvdfxBhTliUJDXjCzxXulmpC C2vt29tbGiHtu8ebUW7AN360cJ+2bRNOaDHP88vLy65b4URVVXKklQ8kNBAAP124gyy12vouQpD5 6b3X01prTz3ezEMDYfADhludz+fL5bL1XQQip2Z1XbfrnNZa+zhHRGvNPDQQBj9juEnghJZtwK+/ CE/29957+7rktMML0ikGhMQpWPhZmISWLDTGyNNfa22MsdbO82yMmed5miat9TzPwVYAj+M4DIO/ ad0AjDF5nmvtZpd+5qGBwAhp/MBrQltrJYyzLJMAkP+83otDfo8si5JRaDloUvLbd2C3bWuMqeva 66t4led5WZZd162/lNaahAZCIqTxHa8JLUlc13We57LX9KdPf4nhZTVRURRSVUuZK2nt6Q7FMAxZ lu23npZiuu/79W+Utbbv+11/ZAH2haMq8SV/Ca21lq02six7uP1Y/unK4Zh93zu9wfcv9P
T0tOtk knO++75fP/BQVdXpdAq55yhwZIQ0PucvoeWMJuk6Xv+slzHwvu/7vh+GwV94/Nd//dd+z5yWt+h8 Pjv5ef/169d+xxWAfWG4G5+Q9dBuA89am2VZWZZlWWZZ5uriy5i5TGw7GdT99FVkmHenFaQMXbhq H+v7XnoI1l8KwPf4McN7UkM7T6O6rk+n0+l0cpjQ18qyrOva06C0NKz5uHIwcuSGk0uN4+jkOgB+ REjjP3jaU+x0OlVVVZal+tsI5oPMc//+/dtHkTeOo5MG6a1IMe1kxH6aJlcj5wC+R0jj33zU0Frr X79+lWXpaX/Kd6ST+fn52cdHgQCd5F5JN4CTv4I02K+/DoDvEdL4F+edYrK9szQZBZ6/zPP8169f bl/UWtt13a6TyVorHfXrLyXr39ZfB8D3CGko5WGUW7Z3Pp1OYQroj6SedpjTUprvOqSXfWPWX0o+ spDTgG+ENNyPcsvccF3X265ZyrKsaRqHF5SFTLse8TbGOHlPZA842QZu/dUAfIWQPjrnNXSe503T bJ7Q6u9BjQ77vSWZdl1Mq7/TEE4udblcEjh1G4gZIX1ozmtoCcU8zyNZRCsrsx3uvCHlo6urbcLh FqcJDC0AkYviSYpNOO8Uiy2hhRwv4epqywGari64iaIonOT0PM/DMOz93QBiFtHDFCE5T2jZKyO2 hBZlWTo8U9nrPuFhuGofU0pN05TAGwJEK7rnKQLwNA8dZ0ILh8vA5OhMJ5faipw46arNW04OXX8p AB9F+kiFP8735Y5zlPuatEplWeZkYFZOyVx/nW1Za8uydPLP4HK5ENKAJ5E+VeFJ8p1iX3FYO6ax 7ki2ZnN1tb1v8wJEK+oHK9w6SKfYV5ycjLlcJ4GcluXs66+jtZYNUxN4T4DY7ODZCicOntBKKWOM k0ySpdJ7n5ZWrtvHnJ9tCkAR0gdBQqu/m2Kuv+GUoqiqKidrsaSYps0bcG43T1g8jIReOLlnCek0 hnblyA0nHzvmeR7
HMY23BYjHzh6yuBcJ/c766WRrbQLd3UIOmXY1NtD3fTLvDBCJXT5ncSMS+h3Z zdvJdZIZ9JZdaJxUwPLxZe/bpgJR2eWjFrc41J5iN3IyLZ3AZibvZFnm5LOLtfZyuTDiDTi016ct vuejho58T7Ebrc9XaYpOKYqKonC4vXnXdSm9OcC29v3AxacY5f6GMWZlTstmJikV09Za2ZHNyaVk zfT6SwFQhHR6SOgfrYkQieeUElr9bR9zNTwwDEPXdeuvA0AR0okhoW+xJmLd5lk8tNZ1Xbva22QY Btq8ASfSefKChL7RynzVf7m6n0i4an1XStHjDbiS1MP3yEjoG83zvCY/ZLg7sTJaZFnmZPcxpZS1 tm1bjtwA1kvq+XtYrLa63TzPa/5SMtyd3tsi8jx3tUsoG5ABTqT5rDkUVlvdTnqP11fS6Y11C4fT 7dbarutSfaOAYFJ7Ch8No9x3keMU1yRHlmUOlxRHSL77Ti41jiNt3sBKCT6Ij6NtWxL6LnLK5Jor HGH81uGnEDrIgJXSfBYfQdu2bds6vGDyCS1l9JqQljOjUn1/hDGmKApXn0W6rmMtFrBGyo+bhJHQ j1k/+rp+w7L4Sdugq6v1fU+bN/CwlJ/IqTqfzyT0A6y1K4de3e5xHS1ZMO3qH8MwDMl/rAH8Sfmh nCTmoR+28rRja23yb9GiLEtX7WOyZvoIc/mAD0d56KSBUe6HrW8Z01pXVXWcorAoCld/2WmaWDMN PCbxR3NKSOg1pmlaMyFtrc2yLOEV0u9orYuiMMa4OnKDQW/gMek/ndNAQq8xTdP6EVeHI8C7ICMH Dmemh2FwcingUNJ/QCeAhF5j2WVsTSVXFIWrfa33wmH7mNZ6HEfOmQYekP4zeu/o5V5Ja9113cq+ bmOMq2Mcd8ThkRta67Zt2dgEuNchHtP7xa6f653P55X7aRhjmqZxdT87IjPTDj+dDMNAMQ3c5ShP 6j1ilHu9vu/XB4NMRR+z78lh+5i1tu/79dcBD
uUoD+vdadv2fD47DIYDJvQ0TcMwrN/uqizLA451 C2tt0zSu/vore+yBAzrK83pfpIZ2mNAJnw/9jWEY1kdCXddHaxm7JqvOHJ5f6eRjE3AcB3pk74WP Ue5Uz4f+Rtd15/N55UXyPHe4p8dOZVnmcBeXYRg4cgO43YGe2rsgo9wOL3jAUW6l1DAMThruHLY3 75ocjeXqahy5AdzuQA/u+Dkf5T5sQjtZ7SMjEE5uae/yPHe4kYssW3d1NSBtB3p2R44a2omlWWzl HKox5lA7df+oqipXOT3P8+VyYS0WcIsDPb5jRg3thBzk0Pf9+gCQ2pGQXkj7mKtLFUVBSAO3ONAT PFrOa2ittWw0faiEnud5HMfz+bx+KFW2rT7ssqtPaa3rul7/qUVr3TSNLL92cmNA2vg52Zjs+um2 YrPWzvN8qEpF/squzi0+nU6HOkvjRvLZZeUVJKH5AATciCfRltq2dbvr56LrOqlUDvI0tNa+vb2t r6GttVJDf/qxyVorvy7HdVx/IJD/XH5xOdRy+SPLF/tljJEpgMc+CZHQwAMI6c10Xed2PfQ1a+1y 8eSfifM8v76+rl/VY63N8/zjkZTLyMQ8z9KStryWtdZaKxtnyhdyP1mWyS9qrY0x1xO68oX8r93F tiwcf2B3TxIaeAwhvQ15oOd57m9jh4PktCS0q7exLMuyLNXfYFZK9X0v2Sw5vRSR7+rm5dfl64+f GCSPrzNbvinygUB+Mf5qW86vvHc7dBIaeNiDI1dYz1o7juPlchmGwd+rpP18dJvQVVU1TSPfl2WX 6ZUHUX9Ffu4km5VS0uW3jCfHnNnW2j9//tw1bnE6nVL9Fwj4RkhvKUxOq0Sfkm4TWilV1/U4jp/W wb4tFbnEs0S11PRLkEcS2HKY1fl8vuXRIT3hRz6hBFiJ4e4tyeO4rmullNecTm/c23lCK6Wct9nf bnldGWOXTwlSysvm4bIx5/VZFxve6u3/ihIexQHCoJLentTTbdt6PXggpXF
vHwkdrWVgfOljkN3Q 5D+3KrIvl8v3i/tT+vcGbIiQjgLz07c7VEK/s3SryXdQesjzPJc1Y1JkhwnsYRjO5/M38wJJzrAA 4THcHYUw494J9HvP8/zy8nLYM5SWullGxZf+c6WUtIsvrWcS2/4yuyiKPM8//Uak8VkQiASVdESo p7935Br6R+8mqsuylNYzWY0tC7gdBra0172+vr7bQGa//7qAOFFJR4R6+hsk9PeuA1gasNXfIvt6 fZcxxknrmQS/MWaapuU6JDTgHJV0dILV0ztaG3PwUe6VriNZTqCS7/6yIZp6NLCHYXh5eZGvSWjA B0I6Rox7X7PWvry8UEM7scxSyzC4TF1L69kDRfY0TW3b9n2/l39LwO4Q0pFinxNBQochJbVEdVEU 6m/r+I+tZ3JIDAkNeEJIx4t6moQOaVnfJaksRz7L2PiygcnHwJZjvJetyAG4RUhH7cg5TUJv6HpU XCl1XWTL8Pi7k0Ui2bIUSA8hHbtj5vQDpzjAn3dJLEW2dB1K3xkAT1iCFbsDrsuSGpqEjse79V3D MFyftgnAH0J6Bw6V04xyR06mqGXchTIa8I2Q3oeD5DQJHb/YZkaAtPFBeDeWnJYVMp5Ya8/n8zAM m5ypTEJHTnZBIaGBYKik9yTh86c3SWhZHDzPswzbXrdHLVtSyxd0LytqaGALhPTOJDnuHaaXW5YV ySFRMp9qrZXVRNfrg5f/nOfZ/iX3No6j/KfX+4wWNTQQHiG9P4nltO9ebkliGadVSsnX6ubieIlk iW05UmKaJkluCfJxHL2eC7m5fe30DqSEddJ7lcb6ad+j3LIrdV3X+q/111xKbfnZkbSWhUlKKfk6 sYK7aRoSGtgEIb1jez8vy19CyyresizzPM/zQMNF8qMkc9jzPA/DIN8gKcHD3INz1NDAtgjpfdtv TvtL6CzLqqqSGnqr8efriW2t9TAM8zxLciulZGw//rFxEhrYHCG9e3vMaX8Jnef58/Ozq5Ftt2QM XE6k
kOHxpSUtwh2wSWggBoR0CvaV054SOsuyPM9Pp1NUUfcVCWxjjCxJH8dR0jqSzVBJaCAShHQi 9pLTnlZbyQy0NIi5vXIYy0y2dIy/K7ID/6VIaCAehHQ64s9pTzV0URRFUVRVtdOEfmfpDF9az2Q+ e5qmAH9BEhqICiGdFHmmd13X973XF3pgTY6nhC7LUtrE0kjodySwtdYyHr60ni0brbj9W5PQQGwI 6dTEWU+T0E5c74Bmre37Xorspfhe8z6Q0ECECOkEhamnb3+mk9A+XLeeyWD4sib7gR9qEhqIE9uC Jkj2DZWv/eW0tfZyuSilvn+yk9CeLMvM5FS0pci+Xt+11Nnq2yKbhAaiRSWdrBjqaRJ6E+9msoUE tvrQLk5CAzEjpFO2bU6T0JGQn/ElqqVdfNkNjYQGYkZIJ26rPjISOk7XrWfq7xFhJDQQLUI6feHr aRJ6FyLcixTAOzSOpS9wH1lRFOfzmYSOH+8kED8q6aMIVk9rrZ2fzEhCAzgmKumjCFZPO//YR0ID OCxC+kDC5LRbJDSAIyOkj2VfOU1CAzg4Qvpw9pLTJDQAENJHFH9Ok9AAoAjpw4o5p0loABCE9HHF mdMkNAAsCOlDiy2nSWgAuEZIH92S03K+4YZ3QkIDwDtm6xvA9iSn67qWk4k3QUIDwEdsC4p/CbNv 6KdIaAD4FMPd+Jet5qdJaAD4CiGNfws/P01CA8A3mJP+3HJQxPUXy+FOH/9vMpb56bIsfb+WMSbP cxIaAL5CJa2WuJX/nKbJWqu1nqZp+RX1N4+NMVrrLMvk9xtjjDFKKa21MUb+4N4jJ9i49zRN8zxP 07S8HADg2qEfjvM8S7fUPM+SFpLE745Dlui9/uKaviKloaT4kt97FCantdaXy0XeUnIaAD463JNx nmdjTNd10zQNwyAFsdTKX1XAy69/+huuR7yttV3XLfFcFEWWZXmeL9W2h7+QL8Hq6bZt5eWyLPP3 KgCwR4dYgiUV8DiO1tq+76dpWo
pmf8Epb+xSVZdlaYyRr72+rlth1mVprWUWnJwGgGuJh7QksRTN 4zhKTm8SkPKiRVEYY6qqWkbIw9/JvYKtn26ahpwGgGsph7SUy23bzvM8jqOKZsA5yzKpHWUOe+vb +Rk5DQCbSDOkpXSW6jnav6C1Ns/zoihk6jrywpqcBoDwEgzpruuGYei6TkVTOn9P6um6riNvngqZ 00VR7GKMAQC8SiekZd3U+XyWJVVb387dtNZFUZRlWRRFtJ8tyGkACCmRh+AwDH3fj+O47ECyO9J5 PgxDWZZ5nldVFWETeOB1WYr10wCObfdPQGkKe3t7S2NIQFZaj+M4DEPTNLJBytY39R/IaQAIZt/D 3eM49n2/7Iax9e04lmWZDIBHmFJhxr2ttafTiXFvAIe145CWhAhzWNOGtNan0ynP89h6yshpAPBt fw8+mak9n8/DMOx3Bvp28zy/vb3JeY5VVW19O/8WbH9vxr0BHNbOnnqyfdjlcvHdXRwPGcaXgnWa ptPpFE9DWcj5aRnyIacBHMqeHnnW2mEYLpeLbB92NPM8Xy6XaZpkmVYkDWXBcprzsgAc0G6ed/M8 yy4lx0xo9bekHoZBGtrruo5klpp+bwDwZB8Pu3me27aVfNr6XrYne5LP83w6nYwxMQx9Lzktox3+ Xuh8PjdNo8hpAMewg+5uEvorxpimaeJp/JZ+78vl4rvlnv3IABxE7CE9TVPbtjvd6TMArXXTNLKi eut7UYqcBgCnog7paZpeXl6I5+/JUHNVVWVZbn0vSgVcPy3nZZHTABIW7wOOhL6RTANba621MSyk DjM/rbWm3xtA8iJ9usWT0MtIw8f+rHjWKyulxnGUSQHpq9qW5LQcvkm/NwA8LMZH2zAMb29vwRJa YljiVg600H8ta5G11tJTLV/In5rnOaqcVn83/aiqavOub9ZlAcB60T3XLpfLsr1UABLGZVlKqGRZ Zq2VhLsOb/W3bpZRZa31PM8S2+M4yj5o8zwvf2pDl8tlnmfZ
RvQ4Oc1+ZACSFNdDLUxCy/Wl3JRg XlL5OtXeJdxSai//mee5lK1aaxlqnqZJpoeXstvrX+QrSyIeJ6cvl4t8QU4DSElET7S2bS+Xi++E 1lpXVVUURZZl75YX35Vn7zJ7aZWq61qmh5fAdnfvd5BEtNYWRUFOA8BObT88K7zW0FLUSio3TXM9 2eyPFNNd10laqy1OvM6yrCxLaeAK/NLvsC4LAB4QxbMsQELLMuKQw79Spsskt0R113WBw3Kapr7v JbqOUE+zLgtAYrZ/kPlO6KIoyrKUBcThg0oa05qmkdOr5BirkKMXy5HbB8lpRR8ZgIRs/BTz3Skm m0fGsGWmDLYbY2TUd8nOAA6Y09TTANKw5SPMd0L//v3bGBPJuctCmsmrqjqfz9M0BTt284A5zfpp AAnYrHHMX0IbY6RBLPKn8zAMfd93XRfsFeUcjs1zWtFHBgC32ebh5TWh8zyXg6GcX9wtWQaW53nX dWFK6qPV01rrtm0Z9wawXxs8ufwltBTQHxdAR8sYI3uqSE4H2An1mDktX5PTAHYn9GPrcrl42rFE TnTI8zyqSehbFEUhDWVt24bJaXn/D5LTivlpALsV9JklCe0jh4qiOJ1OYXYp8UEav4uieHl5CdD4 Pc+z7K9CTgNAzMI9sPwldFmWz8/PsR1IdS9ZUf3r16/L5TIMg++oluvneX6cfUPJaQC7E+hp5Tuh 1RYblfhgjFkOhA6Q033fS0YeJKfP5/PpdFLkNICdCPGo8pTQWuuiKCShUyI7lBVF4XuFkjreeVn0 kQHYF+/PKU+93HJ0xFJ0JmZJLGutTB77c7ScVox7A9gPv5uZeKqhZdOuuq7dXjY28q2RTzm+X6uu axkH3lywfU5Op1NRFOQ0gJh5fEL5q6GPkNDq7yy7jBb4zmk5jDmGnA427s38NID4+Xo8eVoPvRyQ 7PaykQuW0zId7vVVbhEyp+XvS04DiJOXZxOj3M41TbNsTObpJay1l8tFNkHz9BK3C3n+tH
xNTgOI kPsHEwntSVVVEiqeclprPc9z13Va67IsfbzEvfcT7FxL+YKcBhAbx08lEtoryU6vOT0Mg2x/FkNi 0e8N4OBcPpJI6AAC5HTXdcYYrXUM55Qw7g3gyJw9j0joYHzntFw8z/MYQlr93bVGvmbcG8ChuDmO goQOTFrc/WWJtfb19TXMKdc3Koqiqirfk+Vt2/Z9H9VfHMCROXjKk9CbWOrpYRh87BQmzd5yPrfz iz8mQD3NuDeAqKx9DJHQGyrLUlaie6r8pImsqqp4DgBl3BvAoax6BpHQm/O6Lsta2/e9fBSI55Ax chrAcTxeIZHQkZD56SzLfGzDPk3T+XyOJ6EF89MADuLBKoGEjkpZlvM8+xv0bts2hu1CrzE/DeAI HqmkSegI1XXtL0eHYfB9svUDpJ72vYmpbEHv9bA4APjK3fUBZ1tF63Q6aa19nMMxjuMwDHmex9NB JpZ6uus6H9e31jZNo7WObcAfwEHc98z1d7YVCe1E0zSe3kavZ3usURRFWZae6ummacqyZKwbwFbu ePp4GuWWY5dIaFfqup7n2cfotJyRFWFieaqn67omoQFs69YHEPPQe6G1lrLSeU5P0zRNkzEmtkFv 5TqnZZSbhAawuZueQf4SWpYPub3swS0nUjjv95Y9yGI4xfJTDnOahAYQiZ9LIq8JHdvCnjRITvs4 IUOWTUfb6uxkfppRbgDx+OFJ5K+Xm4T2Smstb+88z26/fdM0jeO4lK2xWVlPk9AAovJdJe2vl5uE DkBy2nkxLcux3F7TrYfraRIaQGy+DGl/vdwkdDBa61+/fjnP6b7vE8tpay0JDSBCn4e0115uEjqw uq7d9mPP8zxNU7Qz0+KunKZTDECcPnl2yzw0nWJpkCaysizd7pnl4zOcc7fkNDU0gJi9D2nmodOT ZVlRFG4Hved57rou8mJa3ZDT1NAAYvYfIc08dKqKonC+Hn0cx/iLafVtTlNDA4jcv0Oaeei0Oc/p aZoibx9bfJrTJDS
A+P0rpLuuo4ZOm9a6LEuH+4VZa4dhmKbJ1QW9epfTJDSAXciVUl3X+egUk02k Seh4ON+DbBiGeZ6dL/HyZNnnRD6vkNAA4pd3Xedpo0e5prWWs3jj0TTNNE0Oz97o+z7LsgiP3PhU URRyq3v5YAHg4IyPXT8Xfd/76BXHw2TFkcNMjfOQ6W9kWUZCA9gL89///d/+ri5FGzkdD621MaYo ClfDG27rcgDANaOU+p//+R9/L0BOx8YYU1WVw2/HXtZiAcDu/GvYk5w+lCzLTqeTq2/Hjnq8AWBf /j03GSCnvc5/43Za6yzLHLY3Oz8QEwCg3u045junh2EgpyMh64adXEoWTDu5FADg2vsuX+rp43C4 bJpKGgB8+GQpjtecnueZejoSDkN6GAZ6vAHAuc/XyzLufQSyJZyrtVh8NwHAuS83tSCnj8AYk+e5 k+9C3/csxAIAt77beYr56eS52thEa22t5VsJAG79sD0k89Np01rnee5kLRY93gDg3M97OFNPpy3P c2PM+vff/uXkrgAA6paQVtTTqSvL0smRG9M08U0EAIdufTTTR5YwSej1b/48zxxLCgAO3VE/kdOp kvax9deZ55liGgAcum+Qk5xOkjEmy7KVRbC1dp5nimkAcOjumUhyOj3W2qIoVk5Lyyosxa4mAODO I89lcjoxWmtjjKvV0k5uCQCgHgtpxbqsFGVZtv4Nn6aJ4W4AcOXxEU7WZaVETphefx2+XwDg0Kpp SMa9k6G1lkHvldfhzEoAcGjtQ5mcTsb6SpodxwDALQf7TJHTaVjf9iWz0XynAMAVByGtyOlUrCym Zam0q5sBALgJaUVO758xxskO3nyPAMAVZyGtyOn9W7mpp6v11gAA4TKkFTm9Z+u7u2kcAwC3HIe0 Iqd3y1orC7HWXIQlWADgkPuQVuxHtlsrS2GGuwHALS8hrdiPbJ/Wv58kNAA45CukFfX0Dq2vgwlp AHDIY0gr6uldkdOg17yZTma1AQALvyGt6CPbD
2vtyjOs5JQOQhoAXPEe0oqc3gmpg1dexBjDNwIA XAkR0ipUTrMn5RrjOK5/A52cdwkAEIFCWgXpI7tcLpRxj5HZ6PWVtJOLAABEuJBW9JFFTN69lRfJ 89zJ7t8AABH6kcq4d4RcfaxZv7EoAODaBo/UADnNuPe9+r6fpmnNFbTWeZ67uh8AgNokpBX93pFZ v/hKLpLnORPSAODQZoOTjHvHo+/7lRPS1lr6ugHAuS1nEMP0e5PT35vneeVAt/o71l0UhZNbAgCI jdt8AvR7k9Pfm+e57/uVF5G9xphfAAC3tu/FpZ7ekCT0+jdHa12WJRPSAODW9iGt/NfT5PSnpPAd x3F9yxgD3QDgQxQhrcjpLWitu64bx3H9pdjGBAB8iOjBSk4H1vf9+tlopVRRFLR2A4APEYW0IqcD krXR6/u6lVJ5nrONCQD4EFdIK3I6lHEc27Zdfx1jTFVV668DAPgoupBW5LR/4zheLhcnl2KXMQDw J8aQVuS0T7J83Em/mFKqqipaxgDAk3gfr+S0D9Zaa23XdU42HqnrmpYxAPAn3pBW5LQHWuvz+ezk rywHU1JGA4A/sT9hyWm3zufzyrM0FkVR1HXt5FIAgE/FHtKKnHanbVtXCZ1lWV3XbNYNAF7tIKQV Oe3CMAzDMDhZGC3HaRhj6OsGAK/2EdKKnF5nGIa+7111dGutm6ZhNhoAfNvTc5acfoz81bquc3XB pmlo6gaAAPYU0oqcfojbhC7LkoQGgDB2FtKKnL7T5XI5n8+u23p6IwAAA81JREFUrqa1LoqCnboB IIz9hbQip2/mNqGVUlVVsVM3AASzy5BW5PQN+r53m9BlWZLQABDSXkNakdPfGobB4Ty0UsoYUxQF Hd0AENK+n7nk9KeGYbhcLq4WXCmljDFlWZZlycJoAAhp3yGtyOkPloR2uB2YMaZpGhIaAALbfUgr /znddd1ectpTQj8/P5PQABBeCiGtPOe0tXYX9bSnhD6dTiQ0AGwikZBWhx/
3loQehsFhQmut5cRo QhoANpFOSKsD57TzTjGR53lRFOwvBgBbSSqk1SFz2scot/p7XDQJDQAbSi2k1cFyehiGtm3dJrS1 Vga6i6JwdU0AwAMSDGl1mJyWGnqaJrc1tNb6dDqR0ACwuTRDWh0gpz2Nciulnp6e2P4TAGKgnT/i o/K///u//i6uta6qqq7r8JtlktAAcATJVtIiyfXT/hK6aZqyLN1eEwDwsMRDWgUZ927bNlhO+0vo qqrYnRsAopJ+SCv/OS0t1gFy2ndCs+AKAKJyiJBWSeS0v4SWE65o5waA2CTeOPaO1z4yOXG5aRof fWS+a2gSGgAidJRKWuy0niahAeCYjhXSaoc5TUIDwGEdLqTVrnKahAaAIzvWnPS1+Oenl9MnHd6Y IKEBYBeOWEmLyOtpT6dPKhIaAPbjuCGtIs5pRrkBAOrIw92L2Ma9GeUGAIhDV9IiqnqahAYALAhp paLJaeahAQDXCOl/2TynmYcGALzDnPR/2Gp+WiJ8miYSGgCwoJL+D5vU01JDk9AAgHcI6fcC5zSj 3ACArzDc/bkw497TNJHQAICvENJf8p3TWZZZa+nlBgB8hZD+jteclndea+32siQ0ACSDkP6B15x2 joQGgJTQOPYDr31kbpHQAJAYQvpnu8hpEhoA0kNI3yTynCahASBJhPStos1pEhoAUkVI3yHCnCah ASBhhPR9osppEhoA0kZI3y2SnCahASB5hPQjNs9pEhoAjoCQftCGOU1CA8BBENKP2ySnSWgAOA5C epXAOU1CA8ChENJrBcvpsixJaAA4FELagQA5XZZlVVUkNAAcCqdgOePvvCxGuQHgmKiknfFUT5PQ AHBYhLRLznOahAaAIyOkHXOY03SKAcDBEdLuOclpOsUAAIS0FytzmoQGAChC2p+Hc5qEBgAIQtqj B3KahAYALAhpv+7KaRIaAHCNkPbuxpwmoQEA7xDSIfyY0yQ0AOAjQjqQb3JaEjrP85D3AwCIHyEd zqc5
vSS01jr8LQEAYkZIB/Uup0loAMA3COnQlpwmoQEA3+Ooym28vr6S0ACA7/0/YBJ1/NDwq84A AAAASUVORK5CYII= "
+ x="0"
+ y="0"
+ width="652"
+ height="694"
+ id="image10" />
+</svg>

Added: sandbox/SOC/2007/quan/libs/quan/doc/doxygen/important.png
==============================================================================
Binary file. No diff available.

Added: sandbox/SOC/2007/quan/libs/quan/doc/doxygen/proposed_for_boost.png
==============================================================================
Binary file. No diff available.

Added: sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxyfile.txt
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/quan/libs/quan/doc/doxygen/quan_doxyfile.txt 2012-10-05 10:48:15 EDT (Fri, 05 Oct 2012)
@@ -0,0 +1,1810 @@
+# Doxyfile 1.8.0
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
+
+PROJECT_NAME = Boost.Quan
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF = "Boost.Quan library of uncertain functions"
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO = Proposed_for_Boost.png
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY =
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 12
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = NO
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields will be shown inline in the documentation
+# of the scope in which they are defined (i.e. file, namespace, or group
+# documentation), provided this scope is documented. If set to NO (the default),
+# structs, classes, and unions are shown on a separate page (for HTML and Man
+# pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS = NO
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penalty.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will roughly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+SYMBOL_CACHE_SIZE = 0
+
+# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
+# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
+# their name and scope. Since this can be an expensive process and often the
+# same symbol appear multiple times in the code, doxygen keeps a cache of
+# pre-resolved symbols. If the cache is too small doxygen will become slower.
+# If the cache is too large, memory is wasted. The cache size is given by this
+# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+LOOKUP_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+
+EXTRACT_PACKAGE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = NO
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = NO
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = NO
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = NO
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= NO
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = NO
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
+# feature you need bibtex and perl available in the search path.
+
+CITE_BIB_FILES =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE = doxywarn.log
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = ../../../../boost/quan \
+ ../../src
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS = *.cpp \
+ *.ipp \
+ *.hpp
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE = "../../../../boost/quan/meas - all const.hpp" \
+ ../../../../boost/quan/meas2.hpp \
+ "../../../../boost/quan/unc - all const.hpp" \
+ ../../../../boost/quan/uncbools.hpp \
+ ../../../../boost/quan/uncdata.hpp \
+ ../../../../boost/quan/uncs.hpp \
+ "../../src/Boost CHECK expanded macros.cpp"
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is advised to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER = quan_doxygen_header.html
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER = quan_doxygen_footer.html
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# style sheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET = quan_doxygen.css
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the style sheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 104
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 82
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
+# at top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it. Since the tabs have the same information as the
+# navigation tree you can set this option to NO if you already set
+# GENERATE_TREEVIEW to YES.
+
+DISABLE_INDEX = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+# Since the tree basically has the same information as the tab index you
+# could consider to set DISABLE_INDEX to NO when enabling this option.
+
+GENERATE_TREEVIEW = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE = 4
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you may also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to
+# the MathJax Content Delivery Network so you can quickly see the result without
+# installing MathJax. However, it is strongly recommended to install a local
+# copy of MathJax from http://www.mathjax.org before deployment.
+
+MATHJAX_RELPATH = http://www.mathjax.org/mathjax
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE = plain
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load style sheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = YES
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED = __declspec(x)=
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. For each
+# tag file the location of the external documentation should be added. The
+# format of a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths
+# or URLs. Note that each tag file must have a unique name (where the name does
+# NOT include the path). If a tag file is not located in the directory in which
+# doxygen is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
+
+DOT_FONTNAME = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside
+# the class node. If there are many fields or methods and many nodes the
+# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
+# threshold limits the number of items for each type to make the size more
+# managable. Set this to 0 for no limit. Note that the threshold may be
+# exceeded by 50% before the limit is enforced.
+
+UML_LIMIT_NUM_FIELDS = 10
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
+
+DOT_IMAGE_FORMAT = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG = NO
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES