[Boost-commit] svn:boost r46491 - trunk/libs/units/example

From: boost_at_[hidden]
Date: 2008-06-18 16:32:26

Author: matthiasschabel
Date: 2008-06-18 16:32:25 EDT (Wed, 18 Jun 2008)
New Revision: 46491
URL: http://svn.boost.org/trac/boost/changeset/46491

Log:
add example of use with Boost.Lambda
Added:
   trunk/libs/units/example/lambda.cpp   (contents, props changed)

Added: trunk/libs/units/example/lambda.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/units/example/lambda.cpp	2008-06-18 16:32:25 EDT (Wed, 18 Jun 2008)
@@ -0,0 +1,153 @@
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// unit/quantity manipulation and conversion
+//
+// Copyright (C) 2003-2008 Matthias Christian Schabel
+// Copyright (C) 2008 Steven Watanabe
+//
+// 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)
+
+// $Id: lambda.cpp 27 2008-06-16 14:50:58Z maehne $
+
+////////////////////////////////////////////////////////////////////////
+///
+/// \file lambda.cpp
+///
+/// \brief Example demonstrating the usage of Boost.Units' quantity,
+///        unit, and absolute types in functors created with the
+///        Boost.Lambda library and stored in Boost.Function objects.
+///
+/// \author Torsten Maehne
+/// \date   2008-06-04
+///
+/// A mechanical, electrical, geometrical, and thermal example
+/// demonstrate how to use Boost.Units' quantity, unit, and absolute
+/// types in lambda expressions. The resulting functors can be stored
+/// in boost::function objects. It is also shown how to work around a
+/// limitation of Boost.Lambda's bind() to help it to find the correct
+/// overloaded function by specifying its signature with a
+/// static_cast.
+///
+////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include <boost/function.hpp>
+#include <boost/units/io.hpp>
+#include <boost/units/cmath.hpp>
+#include <boost/units/pow.hpp>
+#include <boost/units/systems/si.hpp>
+#include <boost/units/absolute.hpp>
+
+// Include boost/units/lambda.hpp instead of boost/lambda/lambda.hpp
+// for a convenient usage of Boost.Units' quantity, unit, and absolute
+// types in lambda expressions. The header augments Boost.Lambda's
+// return type detuction system to recognize the new types so that not
+// for each arithmetic operation the return type needs to be
+// explicitely specified.
+#include <boost/units/lambda.hpp>
+
+#include <boost/lambda/bind.hpp>
+
+
+int main(int argc, char **argv) {
+
+   using namespace std;
+   namespace bl = boost::lambda;
+   namespace bu = boost::units;
+   namespace si = boost::units::si;
+
+
+   ////////////////////////////////////////////////////////////////////////
+   // Mechanical example: linear accelerated movement
+   ////////////////////////////////////////////////////////////////////////
+
+   // Initial condition variables for acceleration, speed, and displacement
+   bu::quantity<si::acceleration> a = 2.0 * si::meters_per_second_squared;
+   bu::quantity<si::velocity> v = 1.0 * si::meters_per_second;
+   bu::quantity<si::length> s0 = 0.5 * si::meter;
+
+   // Displacement over time
+   boost::function<bu::quantity<si::length> (bu::quantity<si::time>) >
+       s = 0.5 * bl::var(a) * bl::_1 * bl::_1
+           + bl::var(v) * bl::_1
+           + bl::var(s0);
+
+   cout << "Linear accelerated movement:" << endl
+        << "a = " << a << ", v = " << v << ", s0 = " << s0 << endl
+        << "s(1.0 * si::second) = " << s(1.0 * si::second) << endl
+        << endl;
+
+   // Change initial conditions
+   a = 1.0 * si::meters_per_second_squared;
+   v = 2.0 * si::meters_per_second;
+   s0 = -1.5 * si::meter;
+
+   cout << "a = " << a << ", v = " << v << ", s0 = " << s0 << endl
+        << "s(1.0 * si::second) = " << s(1.0 * si::second) << endl
+        << endl;
+
+
+   ////////////////////////////////////////////////////////////////////////
+   // Electrical example: oscillating current
+   ////////////////////////////////////////////////////////////////////////
+
+   // Constants for the current amplitude, frequency, and offset current
+   const bu::quantity<si::current> iamp = 1.5 * si::ampere;
+   const bu::quantity<si::frequency> f = 1.0e3 * si::hertz;
+   const bu::quantity<si::current> i0 = 0.5 * si::ampere;
+
+   // The invocation of the sin function needs to be postponed using
+   // bind to specify the oscillation function. A lengthy static_cast
+   // to the function pointer referencing boost::units::sin() is needed
+   // to avoid an "unresolved overloaded function type" error.
+   boost::function<bu::quantity<si::current> (bu::quantity<si::time>) >
+       i = iamp
+           * bl::bind(static_cast<bu::dimensionless_quantity<si::system, double>::type (*)(const bu::quantity<si::plane_angle>&)>(bu::sin),
+                      2.0 * M_PI * si::radian * f * bl::_1)
+           + i0;
+
+   cout << "Oscillating current:" << endl
+        << "iamp = " << iamp << ", f = " << f << ", i0 = " << i0 << endl
+        << "i(1.25e-3 * si::second) = " << i(1.25e-3 * si::second) << endl
+        << endl;
+
+
+   ////////////////////////////////////////////////////////////////////////
+   // Geometric example: area calculation for a square
+   ////////////////////////////////////////////////////////////////////////
+
+   // Length constant
+   const bu::quantity<si::length> l = 1.5 * si::meter;
+
+   // Again an ugly static_cast is needed to bind pow<2> to the first
+   // function argument.
+   boost::function<bu::quantity<si::area> (bu::quantity<si::length>) >
+       A = bl::bind(static_cast<bu::quantity<si::area> (*)(const bu::quantity<si::length>&)>(bu::pow<2>),
+                    bl::_1);
+
+   cout << "Area of a square:" << endl
+        << "A(" << l <<") = " << A(l) << endl << endl;
+
+
+   ////////////////////////////////////////////////////////////////////////
+   // Thermal example: temperature difference of two absolute temperatures
+   ////////////////////////////////////////////////////////////////////////
+
+   // Absolute temperature constants
+   const bu::quantity<bu::absolute<si::temperature> >
+       Tref = 273.15 * bu::absolute<si::temperature>();
+   const bu::quantity<bu::absolute<si::temperature> >
+       Tamb = 300.00 * bu::absolute<si::temperature>();
+
+   boost::function<bu::quantity<si::temperature> (bu::quantity<bu::absolute<si::temperature> >,
+                                                  bu::quantity<bu::absolute<si::temperature> >)>
+       dT = bl::_2 - bl::_1;
+
+   cout << "Temperature difference of two absolute temperatures:" << endl
+        << "dT(" << Tref << ", " << Tamb << ") = " << dT(Tref, Tamb) << endl
+        << endl;
+
+
+   return 0;
+}