I cannot seem to figure out how to make a composite unit
out of two existing units from the same system. For example,
say I have a functor F which takes an argument of type
F::arg_type = quantity<time>
and returns a value of type
F::ret_type = quantity<velocity>
Now I want to write an integration function, which should
return the correct type, something like
template<class F>
F::ret_type*F::arg_type // only conceptually
integrate(F& f, typename F::arg_type a, typename F::arg_type b);
so instantiating this with the above functor should produce a
return type quantity
#include
#include
using namespace boost::units;
// functor for velocity as a function of time
struct F
{
typedef quantitysi::time arg_type;
typedef quantitysi::velocity ret_type;
// constant velocity
ret_type operator()(arg_type t) const { return 1.0*si::meters/
si::second; }
};
template<class F>
typename multiply_typeof_helper::type
integrate(F& f,typename F::arg_type a,typename F::arg_type b)
{
// put actual integration algorithm here...
return F(b)*(b-a);
}
int main(void)
{
return 0;
}
There are corresponding xxx_typeof_helper functions for add, subtract,
divide, pow, and root... Of course, if you're using a compiler that
fully supports typeof, these shenanigans shouldn't be necessary at all.
Matthias