[Boost-commit] svn:boost r78827 - trunk/libs/math/example

Subject: [Boost-commit] svn:boost r78827 - trunk/libs/math/example
From: pbristow_at_[hidden]
Date: 2012-06-06 07:26:59

Author: pbristow
Date: 2012-06-06 07:26:58 EDT (Wed, 06 Jun 2012)
New Revision: 78827
URL: http://svn.boost.org/trac/boost/changeset/78827

Log:
Example of using constants
Added:
   trunk/libs/math/example/constants_eg1.cpp   (contents, props changed)

Added: trunk/libs/math/example/constants_eg1.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/math/example/constants_eg1.cpp	2012-06-06 07:26:58 EDT (Wed, 06 Jun 2012)
@@ -0,0 +1,184 @@
+// Copyright Paul Bristow 2012.
+// Copyright John Maddock 2010.
+
+// 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)
+
+/*! \brief Examples of using the enhanced math constants.
+    \details This allows for access to constants via functions like @c pi(),
+    and also via namespaces, @c using @c namespace boost::math::double_constants;
+    called simply @c pi.
+*/
+
+#include <boost/math/constants/constants.hpp>
+
+#include <iostream>
+using std::cout;
+using std::endl;
+
+#include <limits>
+using std::numeric_limits;
+
+/*! \brief Examples of a template function using constants.
+    \details This example shows using of constants from function calls like @c pi(),
+    rather than the 'cute' plain @c pi use in non-template applications.
+
+    \tparam Real radius parameter that can be a built-in like float, double,
+      or a user-defined type like multiprecision.
+    \returns Area = pi * radius ^ 2
+*/
+
+//[math_constants_eg1
+template<class Real>
+Real area(Real r)
+{
+  using namespace boost::math::constants;
+
+  return pi<Real>() * r * r;
+}
+//] [/math_constants_eg1]
+
+int main()
+{
+  
+  { // Boost.Math constants using function calls like pi().
+    // using namespace boost::math::constants;
+ 
+   using boost::math::constants::pi;
+   using boost::math::constants::one_div_two_pi;
+
+  cout.precision(numeric_limits<double>::max_digits10);
+  cout << "double pi =  boost::math::double_constants::pi = " << pi<double>() << endl;
+  //   double pi =  boost::math::double_constants::pi = 3.1415926535897931
+  double r = 1.234567890123456789;
+  double d = pi<double>() * r * r;
+
+  cout << "d = " << d << ", r = " << r << endl;
+
+  float rf = 0.987654321987654321f;
+
+  float pif = boost::math::constants::pi<float>();
+  cout << "pidf =  boost::math::constants::pi() = " << pif << endl;
+  //   pidf =  boost::math::float_constants::pi = 3.1415927410125732
+
+    //float df = pi * rf * rf; // conversion from 'const double' to 'float', possible loss of data
+  float df = pif * rf * rf;
+
+  cout << "df = " << df << ", rf = " << rf << endl;
+
+  cout << "one_div_two_pi " << one_div_two_pi<double>() << endl;
+
+  using boost::math::constants::one_div_two_pi;
+
+  cout << "one_div_root_two_pi " << one_div_two_pi<double>() << endl;
+  }
+
+  { // Boost math new constants using namespace selected values, like pi.
+
+    //using namespace boost::math::float_constants;
+    using namespace boost::math::double_constants;
+
+    double my2pi = two_pi; // Uses boost::math::double_constants::two_pi;
+
+    cout << "double my2pi = " << my2pi << endl;
+    
+    using boost::math::float_constants::e;
+    float my_e = e;
+    cout << "float my_e  " << my_e << endl;
+
+    double my_pi = boost::math::double_constants::pi;
+    cout << "double my_pi = boost::math::double_constants::pi =  " << my_pi << endl;
+
+    // If you try to use two namespaces, this may, of course, create ambiguity:
+    // it is not too difficult to do this inadvertently.
+    using namespace boost::math::float_constants;
+    //cout << pi << endl; // error C2872: 'pi' : ambiguous symbol
+
+  }
+  {
+
+//[math_constants_ambiguity
+     // If you use more than one namespace, this will, of course, create ambiguity:
+     using namespace boost::math::double_constants;
+     using namespace boost::math::constants;
+
+      //double my_pi = pi(); // error C2872: 'pi' : ambiguous symbol
+      //double my_pi2 = pi; // Context does not allow for disambiguation of overloaded function
+
+     // It is also possible to create ambiguity inadvertently,
+     // perhaps in other peoples code,
+     // by making the scope of a namespace declaration wider than necessary,
+     // therefore is it prudent to avoid this risk by localising the scope of such definitions.
+//] [/math_constants_ambiguity]
+
+  }
+
+  { // You can, of course, use both methods of access if both are fully qualified, for examples:
+
+    //cout.precision(std::numeric_limits<double>::max_digits10);// Ideally.
+    cout.precision(2 + std::numeric_limits<double>::digits * 3010/10000); // If no max_digits10.
+
+    double my_pi1 = boost::math::constants::pi<double>();
+    double my_pid = boost::math::double_constants::pi;
+    cout << "boost::math::constants::pi<double>() = " << my_pi1 << endl
+         << "boost::math::double_constants::pi = " << my_pid << endl;
+
+    // cout.precision(std::numeric_limits<float>::max_digits10); // Ideally.
+    cout.precision(2 + std::numeric_limits<double>::digits * 3010/10000); // If no max_digits10.
+    float my_pif = boost::math::float_constants::pi;
+    cout << "boost::math::float_constants::pi = " << my_pif << endl;
+
+  }
+
+  { // Use with templates
+
+    // \warning it is important to be very careful with the type provided as parameter.
+    // For example, naively providing an @b integer instead of a floating-point type can be disastrous.
+    // cout << "Area = " << area(2) << endl; // warning : 'return' : conversion from 'double' to 'int', possible loss of data
+    // Failure to heed this warning can lead to very wrong answers!
+    //  Area = 12 !!  = 3 * 2 * 2 
+//[math_constants_template_integer_type
+    //cout << "Area = " << area(2) << endl; //   Area = 12!
+    cout << "Area = " << area(2.) << endl;  //   Area = 12.566371
+
+    // You can also avoid this by being explicit about the type of @c area.
+    cout << "Area = " << area<double>(2) << endl;
+
+//] [/math_constants_template_integer_type]
+
+
+  }
+  {
+    using  boost::math::constants::pi;
+    double my_pi3 = pi<double>();
+    //double my_pi4 = pi<>(); cannot find template type.
+    //double my_pi4 = pi();
+
+  }
+
+} // int main()
+
+/*[constants_eq1_output
+
+Output:
+
+  double pi =  boost::math::double_constants::pi = 3.1415926535897931
+  d = 4.7882831840285398, r = 1.2345678901234567
+  pidf =  boost::math::constants::pi() = 3.1415927410125732
+  df = 3.0645015239715576, rf = 0.98765432834625244
+  one_div_two_pi 0.15915494309189535
+  one_div_root_two_pi 0.15915494309189535
+  double my2pi = 6.2831853071795862
+  float my_e  2.7182817459106445
+  double my_pi = boost::math::double_constants::pi =  3.1415926535897931
+  boost::math::constants::pi<double>() = 3.1415926535897931
+  boost::math::double_constants::pi = 3.1415926535897931
+  boost::math::float_constants::pi = 3.1415927410125732
+  Area = 12.566370614359172
+  Area = 12.566370614359172
+
+
+] [/constants_eq1_output]
+*/