boost/units/lambda.hpp

   1 // Boost.Units - A C++ library for zero-overhead dimensional analysis and
   2 // unit/quantity manipulation and conversion
   3 //
   4 // Copyright (C) 2003-2008 Matthias Christian Schabel
   5 // Copyright (C) 2008 Steven Watanabe
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 // $Id: lambda.hpp 27 2008-06-16 14:50:58Z maehne $
  12
  13 #ifndef BOOST_UNITS_LAMBDA_HPP
  14 #define BOOST_UNITS_LAMBDA_HPP
  15
  16
  17 ////////////////////////////////////////////////////////////////////////
  18 ///
  19 /// \file lambda.hpp
  20 ///
  21 /// \brief Definitions to ease the usage of Boost.Units' quantity,
  22 ///        unit, and absolute types in functors created with the
  23 ///        Boost.Lambda library.
  24 ///
  25 /// \author Torsten Maehne
  26 /// \date   2008-06-16
  27 ///
  28 /// Boost.Lambda's return type deduction system is extented to make
  29 /// use of Boost.Units' typeof_helper trait classes for Boost.Units'
  30 /// quantity, absolute, and unit template classes.
  31 ///
  32 ////////////////////////////////////////////////////////////////////////
  33
  34
  35 #include <boost/lambda/lambda.hpp>
  36 #include <boost/units/units_fwd.hpp>
  37 #include <boost/units/detail/dimensionless_unit.hpp>
  38 #include <boost/units/operators.hpp>
  39
  40 namespace boost {
  41
  42 namespace lambda {
  43
  44     /// Partial specialization of return type trait for action
  45     /// unit<Dim, System> * Y.
  46     template<typename System, typename Dim, typename Y>
  47     struct plain_return_type_2<arithmetic_action<multiply_action>,
  48                                boost::units::unit<Dim, System>,
  49                                Y > {
  50         typedef typename boost::units::multiply_typeof_helper<
  51             boost::units::unit<Dim, System>, Y >::type type;
  52     };
  53
  54 } // namespace lambda
  55
  56 namespace units {
  57
  58     template<typename System, typename Dim, typename Arg>
  59     struct multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
  60         typedef boost::lambda::lambda_functor<
  61           boost::lambda::lambda_functor_base<
  62               boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
  63               tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
  64           >
  65         > type;
  66     };
  67
  68     /// Disambiguating overload for action
  69     /// unit<Dim, System> * lambda_functor<Arg>
  70     /// based on \<boost/lambda/detail/operators.hpp\>.
  71     template<typename System, typename Dim, typename Arg>
  72     inline const typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
  73     operator*(const boost::units::unit<Dim, System>& a,
  74               const boost::lambda::lambda_functor<Arg>& b) {
  75         return typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
  76                (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
  77                       boost::lambda::lambda_functor<Arg> >
  78                      (a, b));
  79     }
  80
  81 } // namespace units
  82
  83 namespace lambda {
  84
  85     /// Partial specialization of return type trait for action
  86     /// unit<Dim, System> / Y.
  87     template<typename System, typename Dim, typename Y>
  88     struct plain_return_type_2<arithmetic_action<divide_action>,
  89                                boost::units::unit<Dim, System>,
  90                                Y > {
  91         typedef typename boost::units::divide_typeof_helper<
  92             boost::units::unit<Dim, System>, Y >::type type;
  93     };
  94
  95 } // namespace lambda
  96
  97 namespace units {
  98
  99     template<typename System, typename Dim, typename Arg>
 100     struct divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
 101         typedef boost::lambda::lambda_functor<
 102           boost::lambda::lambda_functor_base<
 103             boost::lambda::arithmetic_action<boost::lambda::divide_action>,
 104               tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
 105           >
 106         > type;
 107     };
 108
 109     /// Disambiguating overload for action
 110     /// unit<Dim, System> / lambda_functor<Arg>
 111     /// based on \<boost/lambda/detail/operators.hpp\>.
 112     template<typename System, typename Dim, typename Arg>
 113     inline const typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
 114     operator/(const boost::units::unit<Dim, System>& a,
 115               const boost::lambda::lambda_functor<Arg>& b) {
 116         return typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
 117                (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
 118                       boost::lambda::lambda_functor<Arg> >
 119                      (a, b));
 120     }
 121
 122 } // namespace units
 123
 124 namespace lambda {
 125
 126     /// Partial specialization of return type trait for action
 127     /// Y * unit<Dim, System>.
 128     template<typename System, typename Dim, typename Y>
 129     struct plain_return_type_2<arithmetic_action<multiply_action>,
 130                                Y,
 131                                boost::units::unit<Dim, System> > {
 132         typedef typename boost::units::multiply_typeof_helper<
 133             Y, boost::units::unit<Dim, System> >::type type;
 134     };
 135
 136 } // namespace lambda
 137
 138 namespace units {
 139
 140     template<typename System, typename Dim, typename Arg>
 141     struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
 142         typedef boost::lambda::lambda_functor<
 143           boost::lambda::lambda_functor_base<
 144             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
 145               tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
 146           >
 147         > type;
 148     };
 149
 150     /// Disambiguating overload for action
 151     /// lambda_functor<Arg> * unit<Dim, System>
 152     /// based on \<boost/lambda/detail/operators.hpp\>.
 153     template<typename System, typename Dim, typename Arg>
 154     inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
 155     operator*(const boost::lambda::lambda_functor<Arg>& a,
 156               const boost::units::unit<Dim, System>& b) {
 157         return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
 158                (tuple<boost::lambda::lambda_functor<Arg>,
 159                       typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
 160                      (a, b));
 161     }
 162
 163 } // namespace units
 164
 165 namespace lambda {
 166
 167     /// Partial specialization of return type trait for action
 168     /// Y / unit<Dim, System>.
 169     template<typename System, typename Dim, typename Y>
 170     struct plain_return_type_2<arithmetic_action<divide_action>,
 171                                Y,
 172                                boost::units::unit<Dim, System> > {
 173         typedef typename boost::units::divide_typeof_helper<
 174             Y, boost::units::unit<Dim, System> >::type type;
 175     };
 176
 177 } // namespace lambda
 178
 179 namespace units {
 180
 181     template<typename System, typename Dim, typename Arg>
 182     struct divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
 183         typedef boost::lambda::lambda_functor<
 184           boost::lambda::lambda_functor_base<
 185             boost::lambda::arithmetic_action<boost::lambda::divide_action>,
 186               tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
 187           >
 188         > type;
 189     };
 190
 191     /// Disambiguating overload for action
 192     /// lambda_functor<Arg> / unit<Dim, System>
 193     /// based on \<boost/lambda/detail/operators.hpp\>.
 194     template<typename System, typename Dim, typename Arg>
 195     inline const typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
 196     operator/(const boost::lambda::lambda_functor<Arg>& a,
 197               const boost::units::unit<Dim, System>& b) {
 198         return typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
 199                (tuple<boost::lambda::lambda_functor<Arg>,
 200                       typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
 201                      (a, b));
 202     }
 203
 204 } // namespace units
 205
 206 namespace lambda {
 207
 208     /// Partial specialization of return type trait for action
 209     /// quantity<Unit, X> * X.
 210     template<typename Unit, typename X>
 211     struct plain_return_type_2<arithmetic_action<multiply_action>,
 212                                boost::units::quantity<Unit, X>,
 213                                X> {
 214         typedef typename boost::units::multiply_typeof_helper<
 215             boost::units::quantity<Unit, X>, X>::type type;
 216     };
 217
 218     /// Partial specialization of return type trait for action
 219     /// X * quantity<Unit, X>.
 220     template<typename Unit, typename X>
 221     struct plain_return_type_2<arithmetic_action<multiply_action>,
 222                                X,
 223                                boost::units::quantity<Unit, X> > {
 224         typedef typename boost::units::multiply_typeof_helper<
 225             X, boost::units::quantity<Unit, X> >::type type;
 226     };
 227
 228     /// Partial specialization of return type trait for action
 229     /// quantity<Unit, X> / X.
 230     template<typename Unit, typename X>
 231     struct plain_return_type_2<arithmetic_action<divide_action>,
 232                                boost::units::quantity<Unit, X>,
 233                                X> {
 234         typedef typename boost::units::divide_typeof_helper<
 235             boost::units::quantity<Unit, X>, X>::type type;
 236     };
 237
 238     /// Partial specialization of return type trait for action
 239     /// X / quantity<Unit, X>.
 240     template<typename Unit, typename X>
 241     struct plain_return_type_2<arithmetic_action<divide_action>,
 242                                X,
 243                                boost::units::quantity<Unit, X> > {
 244         typedef typename boost::units::divide_typeof_helper<
 245             X, boost::units::quantity<Unit, X> >::type type;
 246     };
 247
 248     /// Partial specialization of return type trait for action
 249     /// unit<Dim1, System1> * quantity<Unit2, Y>.
 250     template<typename System1, typename Dim1, typename Unit2, typename Y>
 251     struct plain_return_type_2<arithmetic_action<multiply_action>,
 252                                boost::units::unit<Dim1, System1>,
 253                                boost::units::quantity<Unit2, Y> > {
 254         typedef typename boost::units::multiply_typeof_helper<
 255             boost::units::unit<Dim1, System1>,
 256             boost::units::quantity<Unit2, Y> >::type type;
 257     };
 258
 259     /// Partial specialization of return type trait for action
 260     /// unit<Dim1, System1> / quantity<Unit2, Y>.
 261     template<typename System1, typename Dim1, typename Unit2, typename Y>
 262     struct plain_return_type_2<arithmetic_action<divide_action>,
 263                                boost::units::unit<Dim1, System1>,
 264                                boost::units::quantity<Unit2, Y> > {
 265         typedef typename boost::units::divide_typeof_helper<
 266             boost::units::unit<Dim1, System1>,
 267             boost::units::quantity<Unit2, Y> >::type type;
 268     };
 269
 270     /// Partial specialization of return type trait for action
 271     /// quantity<Unit1, Y> * unit<Dim2, System2>.
 272     template<typename Unit1, typename Y, typename System2, typename Dim2>
 273     struct plain_return_type_2<arithmetic_action<multiply_action>,
 274                                boost::units::quantity<Unit1, Y>,
 275                                boost::units::unit<Dim2, System2> > {
 276         typedef typename boost::units::multiply_typeof_helper<
 277             boost::units::quantity<Unit1, Y>,
 278             boost::units::unit<Dim2, System2> >::type type;
 279     };
 280
 281     /// Partial specialization of return type trait for action
 282     /// quantity<Unit1, Y> / unit<Dim2, System2>.
 283     template<typename Unit1, typename Y, typename System2, typename Dim2>
 284     struct plain_return_type_2<arithmetic_action<divide_action>,
 285                                boost::units::quantity<Unit1, Y>,
 286                                boost::units::unit<Dim2, System2> > {
 287         typedef typename boost::units::divide_typeof_helper<
 288             boost::units::quantity<Unit1, Y>,
 289             boost::units::unit<Dim2, System2> >::type type;
 290     };
 291
 292     /// Partial specialization of return type trait for action
 293     /// +quantity<Unit, Y>.
 294     template<typename Unit, typename Y>
 295     struct plain_return_type_1<unary_arithmetic_action<plus_action>,
 296                                boost::units::quantity<Unit, Y> > {
 297         typedef typename boost::units::unary_plus_typeof_helper<
 298             boost::units::quantity<Unit, Y> >::type type;
 299     };
 300
 301     /// Partial specialization of return type trait for action
 302     /// -quantity<Unit, Y>.
 303     template<typename Unit, typename Y>
 304     struct plain_return_type_1<unary_arithmetic_action<minus_action>,
 305                                boost::units::quantity<Unit, Y> > {
 306         typedef typename boost::units::unary_minus_typeof_helper<
 307             boost::units::quantity<Unit, Y> >::type type;
 308     };
 309
 310     /// Partial specialization of return type trait for action
 311     /// quantity<Unit1, X> + quantity<Unit2, Y>.
 312     template<typename Unit1, typename X, typename Unit2, typename Y>
 313     struct plain_return_type_2<arithmetic_action<plus_action>,
 314                                boost::units::quantity<Unit1, X>,
 315                                boost::units::quantity<Unit2, Y> > {
 316         typedef typename boost::units::add_typeof_helper<
 317             boost::units::quantity<Unit1, X>,
 318             boost::units::quantity<Unit2, Y> >::type type;
 319     };
 320
 321     /// Partial specialization of return type trait for action
 322     /// quantity<dimensionless, X> + Y.
 323     template<typename System, typename X, typename Y>
 324     struct plain_return_type_2<arithmetic_action<plus_action>,
 325                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
 326                                Y> {
 327         typedef typename boost::units::add_typeof_helper<
 328             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
 329             Y>::type type;
 330     };
 331
 332     /// Partial specialization of return type trait for action
 333     /// X + quantity<dimensionless, Y>.
 334     template<typename System, typename X, typename Y>
 335     struct plain_return_type_2<arithmetic_action<plus_action>,
 336                                X,
 337                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
 338         typedef typename boost::units::add_typeof_helper<
 339             X,
 340             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
 341     };
 342
 343     /// Partial specialization of return type trait for action
 344     /// quantity<Unit1, X> - quantity<Unit2, Y>.
 345     template<typename Unit1, typename X, typename Unit2, typename Y>
 346     struct plain_return_type_2<arithmetic_action<minus_action>,
 347                                boost::units::quantity<Unit1, X>,
 348                                boost::units::quantity<Unit2, Y> > {
 349         typedef typename boost::units::subtract_typeof_helper<
 350             boost::units::quantity<Unit1, X>,
 351             boost::units::quantity<Unit2, Y> >::type type;
 352     };
 353
 354     /// Partial specialization of return type trait for action
 355     /// quantity<dimensionless, X> - Y.
 356     template<typename System, typename X, typename Y>
 357     struct plain_return_type_2<arithmetic_action<minus_action>,
 358                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
 359                                Y> {
 360         typedef typename boost::units::subtract_typeof_helper<
 361             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
 362             Y>::type type;
 363     };
 364
 365     /// Partial specialization of return type trait for action
 366     /// X - quantity<dimensionless, Y>.
 367     template<typename System, typename X, typename Y>
 368     struct plain_return_type_2<arithmetic_action<minus_action>,
 369                                X,
 370                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
 371         typedef typename boost::units::subtract_typeof_helper<
 372             X,
 373             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
 374     };
 375
 376     /// Partial specialization of return type trait for action
 377     /// quantity<Unit1, X> * quantity<Unit2, Y>.
 378     template<typename Unit1, typename X, typename Unit2, typename Y>
 379     struct plain_return_type_2<arithmetic_action<multiply_action>,
 380                                boost::units::quantity<Unit1, X>,
 381                                boost::units::quantity<Unit2, Y> > {
 382         typedef typename boost::units::multiply_typeof_helper<
 383             boost::units::quantity<Unit1, X>,
 384             boost::units::quantity<Unit2, Y> >::type type;
 385     };
 386
 387     /// Partial specialization of return type trait for action
 388     /// quantity<Unit1, X> / quantity<Unit2, Y>.
 389     template<typename Unit1, typename X, typename Unit2, typename Y>
 390     struct plain_return_type_2<arithmetic_action<divide_action>,
 391                                boost::units::quantity<Unit1, X>,
 392                                boost::units::quantity<Unit2, Y> > {
 393         typedef typename boost::units::divide_typeof_helper<
 394             boost::units::quantity<Unit1, X>,
 395             boost::units::quantity<Unit2, Y> >::type type;
 396     };
 397
 398
 399     ////////////////////////////////////////////////////////////////////////
 400     // Partial specialization of Boost.Lambda's trait classes for all
 401     // operators overloaded in <boost/units/unit.hpp>
 402     ////////////////////////////////////////////////////////////////////////
 403
 404     /// Partial specialization of return type trait for action
 405     /// +unit<Dim, System>.
 406     template<typename Dim, typename System>
 407     struct plain_return_type_1<unary_arithmetic_action<plus_action>,
 408                                boost::units::unit<Dim, System> > {
 409         typedef typename boost::units::unary_plus_typeof_helper<
 410             boost::units::unit<Dim, System> >::type type;
 411     };
 412
 413     /// Partial specialization of return type trait for action
 414     /// -unit<Dim, System>.
 415     template<typename Dim, typename System>
 416     struct plain_return_type_1<unary_arithmetic_action<minus_action>,
 417                                boost::units::unit<Dim, System> > {
 418         typedef typename boost::units::unary_minus_typeof_helper<
 419             boost::units::unit<Dim, System> >::type type;
 420     };
 421
 422     /// Partial specialization of return type trait for action
 423     /// unit<Dim1, System1> + unit<Dim2, System2>.
 424     template<typename Dim1, typename Dim2, typename System1, typename System2>
 425     struct plain_return_type_2<arithmetic_action<plus_action>,
 426                                boost::units::unit<Dim1, System1>,
 427                                boost::units::unit<Dim2, System2> > {
 428         typedef typename boost::units::add_typeof_helper<
 429             boost::units::unit<Dim1, System1>,
 430             boost::units::unit<Dim2, System2> >::type type;
 431     };
 432
 433     /// Partial specialization of return type trait for action
 434     /// unit<Dim1, System1> - unit<Dim2, System2>.
 435     template<typename Dim1, typename Dim2, typename System1, typename System2>
 436     struct plain_return_type_2<arithmetic_action<minus_action>,
 437                                boost::units::unit<Dim1, System1>,
 438                                boost::units::unit<Dim2, System2> > {
 439         typedef typename boost::units::subtract_typeof_helper<
 440             boost::units::unit<Dim1, System1>,
 441             boost::units::unit<Dim2, System2> >::type type;
 442     };
 443
 444     /// Partial specialization of return type trait for action
 445     /// unit<Dim1, System1> * unit<Dim2, System2>.
 446     template<typename Dim1, typename Dim2, typename System1, typename System2>
 447     struct plain_return_type_2<arithmetic_action<multiply_action>,
 448                                boost::units::unit<Dim1, System1>,
 449                                boost::units::unit<Dim2, System2> > {
 450         typedef typename boost::units::multiply_typeof_helper<
 451             boost::units::unit<Dim1, System1>,
 452             boost::units::unit<Dim2, System2> >::type type;
 453     };
 454
 455     /// Partial specialization of return type trait for action
 456     /// unit<Dim1, System1> / unit<Dim2, System2>.
 457     template<typename Dim1, typename Dim2, typename System1, typename System2>
 458     struct plain_return_type_2<arithmetic_action<divide_action>,
 459                                boost::units::unit<Dim1, System1>,
 460                                boost::units::unit<Dim2, System2> > {
 461         typedef typename boost::units::divide_typeof_helper<
 462             boost::units::unit<Dim1, System1>,
 463             boost::units::unit<Dim2, System2> >::type type;
 464     };
 465
 466
 467     ////////////////////////////////////////////////////////////////////////
 468     // Partial specialization of Boost.Lambda's trait classes for all
 469     // operators overloaded in <boost/units/absolute.hpp>
 470     ////////////////////////////////////////////////////////////////////////
 471
 472
 473     /// Partial specialization of return type trait for action
 474     /// absolute<Y> + Y.
 475     template<typename Y>
 476     struct plain_return_type_2<arithmetic_action<plus_action>,
 477                                boost::units::absolute<Y>,
 478                                Y> {
 479         typedef typename boost::units::absolute<Y> type;
 480     };
 481
 482     /// Partial specialization of return type trait for action
 483     /// Y + absolute<Y>.
 484     template<typename Y>
 485     struct plain_return_type_2<arithmetic_action<plus_action>,
 486                                Y,
 487                                boost::units::absolute<Y> > {
 488         typedef typename boost::units::absolute<Y> type;
 489     };
 490
 491     /// Partial specialization of return type trait for action
 492     /// absolute<Y> - Y.
 493     template<typename Y>
 494     struct plain_return_type_2<arithmetic_action<minus_action>,
 495                                boost::units::absolute<Y>,
 496                                Y> {
 497         typedef typename boost::units::absolute<Y> type;
 498     };
 499
 500     /// Partial specialization of return type trait for action
 501     /// absolute<Y> - absolute<Y>.
 502     template<typename Y>
 503     struct plain_return_type_2<arithmetic_action<minus_action>,
 504                                boost::units::absolute<Y>,
 505                                boost::units::absolute<Y> > {
 506         typedef Y type;
 507     };
 508
 509     /// Partial specialization of return type trait for action
 510     /// T * absolute<unit<D, S> >.
 511     template<typename D, typename S, typename T>
 512     struct plain_return_type_2<arithmetic_action<multiply_action>,
 513                                T,
 514                                boost::units::absolute<boost::units::unit<D, S> > > {
 515         typedef typename boost::units::quantity<
 516             boost::units::absolute<boost::units::unit<D, S> >, T> type;
 517     };
 518
 519 } // namespace lambda
 520
 521 namespace units {
 522
 523     template<typename System, typename Dim, typename Arg>
 524     struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > {
 525         typedef boost::lambda::lambda_functor<
 526           boost::lambda::lambda_functor_base<
 527             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
 528               tuple<boost::lambda::lambda_functor<Arg>,
 529                     typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
 530           >
 531         > type;
 532     };
 533
 534     /// Disambiguating overload for action
 535     /// lambda_functor<Arg> * absolute<unit<Dim, System> >
 536     /// based on \<boost/lambda/detail/operators.hpp\>.
 537     template<typename System, typename Dim, typename Arg>
 538     inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type
 539     operator*(const boost::lambda::lambda_functor<Arg>& a,
 540               const boost::units::absolute<boost::units::unit<Dim, System> >& b) {
 541         return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type::inherited
 542                (tuple<boost::lambda::lambda_functor<Arg>,
 543                       typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
 544                      (a, b));
 545     }
 546
 547 } // namespace units
 548
 549 namespace lambda {
 550
 551     /// Partial specialization of return type trait for action
 552     /// absolute<unit<D, S> > * T.
 553     template<typename D, typename S, typename T>
 554     struct plain_return_type_2<arithmetic_action<multiply_action>,
 555                                boost::units::absolute<boost::units::unit<D, S> >,
 556                                T> {
 557         typedef typename boost::units::quantity<
 558             boost::units::absolute<boost::units::unit<D, S> >, T> type;
 559     };
 560
 561 } // namespace lambda
 562
 563 namespace units {
 564
 565     template<typename System, typename Dim, typename Arg>
 566     struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > {
 567         typedef boost::lambda::lambda_functor<
 568           boost::lambda::lambda_functor_base<
 569             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
 570               tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
 571                     boost::lambda::lambda_functor<Arg> >
 572           >
 573         > type;
 574     };
 575
 576     /// Disambiguating overload for action
 577     /// absolute<unit<Dim, System> > * lambda_functor<Arg>
 578     /// based on \<boost/lambda/detail/operators.hpp\>.
 579     template<typename System, typename Dim, typename Arg>
 580     inline const typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type
 581     operator*(const boost::units::absolute<boost::units::unit<Dim, System> >& a,
 582               const boost::lambda::lambda_functor<Arg>& b) {
 583         return typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type::inherited
 584                (tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
 585                       boost::lambda::lambda_functor<Arg> >
 586                      (a, b));
 587     }
 588
 589 } // namespace units
 590
 591 } // namespace boost
 592
 593 #endif // BOOST_UNITS_LAMBDA_HPP