From: Matthias Troyer (troyer_at_[hidden])
Date: 2006-08-20 15:55:47
On Aug 20, 2006, at 4:19 PM, Andy Little wrote:
> "Matthias Troyer" <troyer_at_[hidden]> wrote
>> On Aug 20, 2006, at 10:42 AM, Andy Little wrote:
>>> "Janek Kozicki" <janek_listy_at_[hidden]> wrote in message
>>>> Andy Little said: (by the date of Sat, 19 Aug 2006 13:03:42
>>> double var1= 10; // var1 meters
>>> double var2 = 10 ; // var2 represents meters.
>>> var1 *= var2 ; // var1 now represents an area in square
>>> Of course you cant do this with a fixed_quantity:
>>> quan::length::m var1(10);
>>> quan::length::m var2(10);
>>> var1 *= var2 ; // Error
>>> I would guess that is an unacceptable restriction for many authors
>>> of algebra
>> Why should this be an unacceptable restriction?
> If you want the highest performance then in place operations are
> faster ( at least in my admittedly limited experience) than binary
> least for UDT's.
>> All it says is that a
>> quantity with units is not a field, but that is obvious from the
>> start. I can multiply a vector (3m, 2m, 1m) by a factor of 5 but not
>> by a factor of 5m. I see no problem here at all, except if you assume
>> that the element type of a vector is the same type as the scalar
>> factor in your expression.
> It is also possible to multiply a vector quantity by a scalar
> #include <quan/three_d/vect.hpp>
> #include <quan/velocity.hpp>
> #include <quan/acceleration.hpp>
> #include <quan/time.hpp>
> #include <quan/mass.hpp>
> #include <quan/length.hpp>
> int main()
> typedef quan::acceleration::m_per_s2 accel;
> typedef quan::velocity::m_per_s velocity;
> typedef quan::length::m length;
> using quan::three_d::vect;
> typedef vect<accel> accel_vect;
> typedef vect<velocity> velocity_vect;
> typedef vect<length> distance_vect;
> accel_vect a(accel(1),accel(2),accel(3));
> velocity_vect u(velocity(0),velocity(-1), velocity(0));
> quan::time::s t(1);
> distance_vect s = u * t + 0.5 * a * quan::pow<2>(t);
> The above creates a lot of temporaries of course.
Why? Using expression templates there will be absolutely no temporaries.
> The fastest way ( at least
> my own admittedly limited experiments) to do this seems to be:
> T s = u;
> s *= t;
s = t*u; seems faster to me since it is only one pass instead of
> T temp = 0.5;
> temp *= a;
> temp *= t;
> temp *= t;
> s += temp;
This is completely wrong. a is a vector and you thus cannot multiply
it to the scalar 0.5
> In fact you can do in place addition of quantities of course, but not
> multiplication, or at least not without low level manipulations.
> It sounds like I am arguing against my own library. I'm not, but I
> am pointing
> out that there are different considerations when using quantities
> and you may
> not ( in fact probably wont) get as good a performance as from
> using inbuilt
> floats. Overall Quan is much more fun to use than floats though,
> and I have
> enjoyed using it so far where possible..
In fact it seems to me that you are much better off using a nice
linear algebra library that makes use of expression templates.
>>> Maybe, if we can get Quan into Boost then we will be in a stronger
>>> position and
>>> there may then be interest in creating a linear generic algebra
>>> library for
>>> physical quantities, but I suspect that due to the above kind of
>>> issues, there
>>> will always be a great divide between a 'raw' linear algebra
>>> library and one
>>> that is designed to work with physical quantities.
>> I don't agree. For me there is no such thing as 'raw' linear
>> algebra. All linear algebra concepts work perfectly with quantities
>> with units.
> FWIW I do see the difference between using quantities and floats as
> coarsely equivalent to the difference between using an assembly
> language and
> (say) C. When using quantities you are effectively using a higher
> language than standard C ++ using floats.
I disagree since the units part is optimized away at compile time and
you should be left just with pure floating point operations at the
end of the day.