On 16 Oct 2014, at 1= 7:37, Shayne Fletcher <s= hayne.fletcher.50@gmail.com> wrote:

Dear OCamlers,

In 1994, Ba= rton and Nackman in their book 'Scientific Engineering in
C++' [= 1] demonstrated how one could encode the rules of Dimensional
Analysis [2] into the C++ type system enabling compile-time checkin= g
(no runtime-cost) of the plausibility (at least up t= o the dimensional
correctness) of computations.

<= /font>
In 2004, Abrahams & Gurtovy in 'C++ Template Metaprogramming= ' [3]
showed the Barton Nackman technique to be elegantly implem= entable
using compile time type sequences encoding integer const= ants. At the
end of this post, I provide a complete listing of t= heir example
program [4].

The key pro= perties of the system (as I see it) are:
- Encoding of in= tegers as types;
= - Compile time manipulation of seq= uences of these integer encodings
to deduce/produc= e new derived types.

Now, it is not immediately = obvious to me how to approach this problem
in OCaml. It irks me = some that I can't immediately produce a yet more
elegant OCaml p= rogram for this problem and leaves me feeling like C++
has "got = something over on us" here ;)

My question theref= ore is: Does anyone have suggestions/pointers
on how to approach= automatic dimensional analysis via the OCaml type
system?&nbs= p;

Best,

--
Shayne Fletcher

[1] John J. Barton and Lee R. Nackm= an. Scientific and Engineering C++:
an Introductio= n with Advanced Techniques and Examples. Reading,
= MA: Addison Wesley. ISBN 0-201-53393-6. 1994.

<= div class=3D"gmail_default" style=3D"">[2= ] Wikipedia h= ttp://en.wikipedia.org/wiki/Dimensional_analysis

=
[3] David Abrahams and Aleksey Gurtovy C++ Template Metaprogramming:
Concepts, Tools, and Techniques from Boost and Beyo= nd (C++ in
Depth Series), Addison-Wesley Profess= ional. ISBN:0321227255. 2004.

[4] Code listing:<= /font>

//"c:/program files (x86)/Microsof= t Visual Studio 10.0/vc/vcvarsall.bat" x64
//cl /F= edimension.exe /EHsc /I d:/boost_1_55_0 dimension.cpp
&nb= sp;
#include <boost/mpl/vector_c.hpp><= /font>
#include <boost/mpl/transform.hpp>
&nbs= p; #include <boost/mpl/equal.hpp>
#in= clude <boost/mpl/plus.hpp>
#include <boos= t/mpl/minus.hpp>
#include <boost/static_asse= rt.hpp>

typede= f boost::mpl::vector_c<int,1,0,0,0,0,0,0> mass;
&nb= sp; typedef boost::mpl::vector_c<int,0,1,0,0,0,0,0> length;
typedef boost::mpl::vector_c<int,0,0,0,1,0,0,0= > charge;
typedef boost::mpl::vector_c<int,0= ,0,0,0,1,0,0> temperature;
typedef boost::mpl::= vector_c<int,0,0,0,0,0,1,0> intensity;
typed= ef boost::mpl::vector_c<int,0,0,0,0,0,0,1> angle;
&= nbsp; typedef boost::mpl::vector_c<int,0,1,-1,0,0,0,0> velocity; &nbs= p; // l/t
typedef boost::mpl::vector_c<i= nt,0,1,-2,0,0,0,0> acceleration; // l/(t2)
type= def boost::mpl::vector_c<int,1,1,-1,0,0,0,0> momentum; = // ml/t
typedef boost::mpl::vector_c<int,1,1,-2= ,0,0,0,0> force; // ml/(t2)
= typedef boost::mpl::vector_c<int,0,0,0,0,0,0,0> scalar;

template <class T, cl= ass Dimensions>
class quantity
= ; {
public:
&nbs= p; explicit quantity (T val)
:= val (val)
{}
&n= bsp; template <class OtherDimensions>
= quantity (quantity<T, OtherDimensions> const& other)
= : val (other.value ()) {
&nbs= p; BOOST_MPL_ASSERT( (boost::mpl::equal<Dimensions, OtherD= imensions>));
}
&nbs= p; T value () const { return val; }
private= :
T val;
};=

template <class T, cla= ss D>
quantity<T, D>
&n= bsp; operator + (quantity<T, D> x, quantity<T, D> y )
return quantity<T, D&g= t;(x.value () + y.value ());
}
&= nbsp;
template <class T, class D>
quantity<T, D>
operato= r - (quantity<T, D> x, quantity<T, D> y )
&nb= sp; {
return quantity<T, D>(x.value (= ) - y.value ());
}
  <= /font>
template <class T, class D1, class D2>
quantity <
T<= /div>
, typename boost::mpl::transform<
&n= bsp; D1, D2, boost::mpl::plus<
&n= bsp; boost::mpl::placeholders::_1=
, boost= ::mpl::placeholders::_2> >::type
><= /font>
operator* (quantity<T, D1> x, quantity <T= , D2> y)
{
typ= edef typename boost::mpl::transform<
&nb= sp; D1, D2, boost::mpl::plus<
&nb= sp; boost::mpl::placeholders::_1
&nb= sp; , boost::mpl::p= laceholders::_2> >::type D;

return quantity<T, D> (x.value () * y.value ())= ;
}

&nbs= p; template <class T, class D1, class D2>
&n= bsp; quantity <
T
&nbs= p; , typename boost::mpl::transform<
&nb= sp; D1, D2, boost::mpl::minus<
&n= bsp; boost::mpl::placeholders::_1
<= div class=3D"gmail_default" style=3D"">&n= bsp; , boost::mpl::placeho= lders::_2> >::type
>
&nb= sp; operator/ (quantity<T, D1> x, quantity <T, D2> y)
{
typedef typename b= oost::mpl::transform<
D1, D2, boo= st::mpl::minus<
&nb= sp; boost::mpl::placeholders::_1
&nb= sp; , boost::mpl::placeholders::_= 2> >::type D;

&nbs= p; return quantity<T, D> (x.value () / y.value ());
}

//= -- test

#include &= lt;iostream>
#incl= ude <limits>
#include <cassert>
=
int main ()
= {
quantity<float, mass> m (5.0= f);
quantity<float, acceleration> a(9= .8f);
quantity<float, force> f =3D m = * a;
quantity<float, mass> m2 =3D f /= a;

assert (= (std::abs ((m2 - m).value ())) <=3D std::numeric_limits<double>::e= psilon ());

= return 0;
}