////////////////////////////////////////////////////////////////////////
// Program to test the combined usage of Boost.Units, Boost.Lambda,
// and Boost.Function
////////////////////////////////////////////////////////////////////////
// File:    units_with_lambda_test.cpp
// Author:  Torsten Maehne
// Created: 2008-05-27
////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <boost/function.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <boost/units/io.hpp>
#include <boost/units/cmath.hpp>
#include <boost/units/pow.hpp>
#include <boost/units/systems/si.hpp>

// This new header maps Boost::Units' typeof helper trait classes to
// the corresponding Boost.Lambda trait classes. If the #include is
// commented out, Boost.Lambda won't be able to determine the return
// type of arithmetic subexpressions.
#include "lambda.hpp"

int main(int argc, char **argv) {

  using namespace std;
  using boost::function;
  using namespace boost::lambda;
  using boost::lambda::_1;
  using namespace boost::units;


  ////////////////////////////////////////////////////////////////////////
  // Mechanical example: linear accelerated movement
  ////////////////////////////////////////////////////////////////////////

  quantity<si::acceleration> a = 2.0 * si::meters_per_second_squared;
  quantity<si::velocity> v = 1.0 * si::meters_per_second;
  quantity<si::length> s0 = 0.5 * si::meter;

  // Displacement over time
  function<quantity<si::length> (quantity<si::time>) >
    s = 0.5 * var(a) * _1 * _1 + var(v) * _1 + 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;

  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
  ////////////////////////////////////////////////////////////////////////

  const quantity<si::current> iamp = 1.5 * si::ampere;
  const quantity<si::frequency> f = 1.0e3 * si::hertz;
  const 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. Can the
  // cast be somehow avoided? If not, how can the syntax at least be
  // simplified?
  function<quantity<si::current> (quantity<si::time>) >
    i = iamp
        * bind(static_cast<dimensionless_quantity<si::system,double>::type (*)(const quantity<si::plane_angle>&)>(sin),
	       2.0 * M_PI * si::radian * f * _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
  ////////////////////////////////////////////////////////////////////////

  const quantity<si::length> l = 1.5 * si::meter;

  // Again an ugly static_cast is needed to bind pow<2> to the first
  // function argument.
  function<quantity<si::area> (quantity<si::length>) >
    A = bind(static_cast<quantity<si::area> (*)(const quantity<si::length>&)>(pow<2>),
	     _1);

  cout << "Area of a square:" << endl
       << "A(" << l <<") = " << A(l) << endl;

  return 0;
}