digitalmars.D - Cool thing about D, number #72

Bill Baxter (19/19) Apr 24 2007 I've always had this dilemma in C++ when writing graphicsy methods,

Daniel Keep (24/57) Apr 24 2007 I discovered the same thing, by roughly the same thinking. I was

Bill Baxter (4/31) Apr 24 2007 I'm just using the compiler's .tupleof property directly.

Daniel Keep (19/53) Apr 24 2007 Tuple!(double,double,double,double) tuple;

Stephen Waits (15/18) Apr 24 2007 Nice.

BCS (3/13) Apr 24 2007 http://www.dsource.org/projects/mathextra/browser/trunk/mathextra/Blade....

David Gileadi (3/19) Apr 24 2007 Seems to have moved slightly, try

=?ISO-8859-1?Q?Jari-Matti_M=E4kel=E4?= (3/7) Apr 24 2007 What version of DMD should be used to make it compile? At least 1.009 -
Stephen Waits (3/5) Apr 24 2007 Thanks guys. Looks bitchin.

Jason House (3/31) Apr 24 2007 This feature is also really cool for generic programming. Code that was...
janderson (5/33) Apr 26 2007 Thats awesome.

Georg Wrede (6/36) Apr 29 2007 In six months I'l go "man there was this thing about using .tupleof when...

janderson (2/41) Apr 29 2007 Start a wiki page?
jcc7 (10/17) Apr 30 2007 In theory, I've collected some of those things in the Tutorials project

=?ISO-8859-1?Q?Lu=EDs_Marques?= (5/15) Apr 27 2007 I finally realize how useful tuples are!

Lutger (3/20) Apr 28 2007 Me too, thanks Bill. These are the 'little' things where D shines and

Bill Baxter <dnewsgroup billbaxter.com> writes:

I've always had this dilemma in C++ when writing graphicsy methods, 
whether a function that takes a point should take separate components 
(float,float,float) or a vector (Vec3f), or perhaps a pointer (float*). 
  In D there's also the option of float[3].  Or just for convenience 
sake maybe overloads for all of the above.

I just realized today the coolness of tupleof for this kind of 
situation.  You can make the function takes the plain floats

    do_something_at_point(float x, float y, float z);

And still call it using a Vec3f via tupleof!

    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);

as opposed to

    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);

It's a minor thing, but it rocks.


--bb

Apr 24 2007

Daniel Keep <daniel.keep.lists gmail.com> writes:

Bill Baxter wrote:
 I've always had this dilemma in C++ when writing graphicsy methods,
 whether a function that takes a point should take separate components
 (float,float,float) or a vector (Vec3f), or perhaps a pointer (float*).
  In D there's also the option of float[3].  Or just for convenience sake
 maybe overloads for all of the above.
 
 I just realized today the coolness of tupleof for this kind of
 situation.  You can make the function takes the plain floats
 
    do_something_at_point(float x, float y, float z);
 
 And still call it using a Vec3f via tupleof!
 
    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);
 
 as opposed to
 
    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);
 
 It's a minor thing, but it rocks.
 
 
 --bb

I discovered the same thing, by roughly the same thinking.  I was
working with DFL and cairo, and was using DFL's color structure.
Problem was that DFL's stored using ubytes, and I wanted doubles.

So when I was writing my own colour structure, as I was defining the
storage, I wrote

 union
 {
     struct { double r, g, b, a; }
     double[4] rgba;
 }

And it suddenly hit me: I could add a tuple!

Now, I have .tuple members for my colour structs, vectors, quaternions,
matrices, and just about every other aggregate type I've written.

One thing that would make this an order of magnitude more useful would
be the ability to return a tuple from a function.

But I agree: it's cool :)

	-- Daniel

P.S.  I use .tuple instead of .tupleof because I don't want to shadow
the very-useful compile-time property :)

-- 
int getRandomNumber()
{
    return 4; // chosen by fair dice roll.
              // guaranteed to be random.
}

http://xkcd.com/

v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D
i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP  http://hackerkey.com/

Apr 24 2007

Bill Baxter <dnewsgroup billbaxter.com> writes:

Daniel Keep wrote:
 
 I discovered the same thing, by roughly the same thinking.  I was
 working with DFL and cairo, and was using DFL's color structure.
 Problem was that DFL's stored using ubytes, and I wanted doubles.
 
 So when I was writing my own colour structure, as I was defining the
 storage, I wrote
 
 union
 {
     struct { double r, g, b, a; }
     double[4] rgba;
 }

 
 And it suddenly hit me: I could add a tuple!

How's that? You add an alias Tuple!(something ) to the union?

 Now, I have .tuple members for my colour structs, vectors, quaternions,
 matrices, and just about every other aggregate type I've written.
 
 One thing that would make this an order of magnitude more useful would
 be the ability to return a tuple from a function.
 
 But I agree: it's cool :)
 
 	-- Daniel
 
 P.S.  I use .tuple instead of .tupleof because I don't want to shadow
 the very-useful compile-time property :)

I'm just using the compiler's .tupleof property directly.

--bb

Apr 24 2007

Daniel Keep <daniel.keep.lists gmail.com> writes:

Bill Baxter wrote:
 Daniel Keep wrote:
 I discovered the same thing, by roughly the same thinking.  I was
 working with DFL and cairo, and was using DFL's color structure.
 Problem was that DFL's stored using ubytes, and I wanted doubles.

 So when I was writing my own colour structure, as I was defining the
 storage, I wrote

 union
 {
     struct { double r, g, b, a; }
     double[4] rgba;
 }

 And it suddenly hit me: I could add a tuple!

 
 How's that? You add an alias Tuple!(something ) to the union?

Tuple!(double,double,double,double) tuple;

Actually, I made a template called repeatT that lets me write that as
repeatT!(4, double) tuple, but you get the idea :)

 Now, I have .tuple members for my colour structs, vectors, quaternions,
 matrices, and just about every other aggregate type I've written.

 One thing that would make this an order of magnitude more useful would
 be the ability to return a tuple from a function.

 But I agree: it's cool :)

     -- Daniel

 P.S.  I use .tuple instead of .tupleof because I don't want to shadow
 the very-useful compile-time property :)

 
 I'm just using the compiler's .tupleof property directly.
 
 --bb

... *slaps forehead*.

In my defense, tho, I imagine it wouldn't have worked quite as well with
the union there :P  Also means I can access the elements as individual
variables, as an array *and* as a tuple.  The last one comes in handy
for unrolling loops :)

	-- Daniel

-- 
int getRandomNumber()
{
    return 4; // chosen by fair dice roll.
              // guaranteed to be random.
}

http://xkcd.com/

v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D
i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP  http://hackerkey.com/

Apr 24 2007

Stephen Waits <steve waits.net> writes:

Daniel Keep wrote:
 
 Now, I have .tuple members for my colour structs, vectors, quaternions,
 matrices, and just about every other aggregate type I've written.

Nice.

Now, I haven't checked in to the world of D in awhile...  I'm wondering 
if you've managed to get to the point of automagic unrolling, factoring, 
and vectorization with these sorts of things (quats, matrices, vectors, 
points)?

In other words.. can we do something along the lines of ..

   Vec3 A,B,C,D,E;
   Vec3 F = A + (Dot(B-A, C+D) * E);

.. and expect it to generate intelligent code, sans temporaries, time 
sucking construction, and so on???

This, minus any sort of vectorization, is doable in C++ through some 
*nasty* template-fu.

What's the state of the art in D?

--Steve

Apr 24 2007

BCS <ao pathlink.com> writes:

Reply to Stephen,

 Now, I haven't checked in to the world of D in awhile...  I'm
 wondering if you've managed to get to the point of automagic
 unrolling, factoring, and vectorization with these sorts of things
 (quats, matrices, vectors, points)?
 

[...]
 
 What's the state of the art in D?
 
 --Steve
 

http://www.dsource.org/projects/mathextra/browser/trunk/mathextra/Blade.d

Apr 24 2007

David Gileadi <foo bar.com> writes:

BCS wrote:
 Reply to Stephen,
 
 Now, I haven't checked in to the world of D in awhile...  I'm
 wondering if you've managed to get to the point of automagic
 unrolling, factoring, and vectorization with these sorts of things
 (quats, matrices, vectors, points)?

 [...]
 What's the state of the art in D?

 --Steve

 
 http://www.dsource.org/projects/mathextra/browser/trunk/mathextra/Blade.d
 

Seems to have moved slightly, try 
http://www.dsource.org/projects/mathextra/browser/trunk/blade

Apr 24 2007

=?ISO-8859-1?Q?Jari-Matti_M=E4kel=E4?= <jmjmak utu.fi.invalid> writes:

David Gileadi wrote:
 BCS wrote:
 Reply to Stephen,
 What's the state of the art in D?


 http://www.dsource.org/projects/mathextra/browser/trunk/blade

What version of DMD should be used to make it compile? At least 1.009 -
1.013 report that they cannot evaluate several functions on compile time.

Apr 24 2007

Stephen Waits <steve waits.net> writes:

David Gileadi wrote:
 Seems to have moved slightly, try 
 http://www.dsource.org/projects/mathextra/browser/trunk/blade

Thanks guys.  Looks bitchin.

--Steve

Apr 24 2007

Jason House <jason.james.house gmail.com> writes:

This feature is also really cool for generic programming.  Code that was 
nearly impossible to write in C++ can be implemented almost trivially.

Bill Baxter wrote:
 I've always had this dilemma in C++ when writing graphicsy methods, 
 whether a function that takes a point should take separate components 
 (float,float,float) or a vector (Vec3f), or perhaps a pointer (float*). 
  In D there's also the option of float[3].  Or just for convenience sake 
 maybe overloads for all of the above.
 
 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats
 
    do_something_at_point(float x, float y, float z);
 
 And still call it using a Vec3f via tupleof!
 
    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);
 
 as opposed to
 
    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);
 
 It's a minor thing, but it rocks.
 
 
 --bb

Apr 24 2007

janderson <askme me.com> writes:

Bill Baxter wrote:
 I've always had this dilemma in C++ when writing graphicsy methods, 
 whether a function that takes a point should take separate components 
 (float,float,float) or a vector (Vec3f), or perhaps a pointer (float*). 
  In D there's also the option of float[3].  Or just for convenience sake 
 maybe overloads for all of the above.
 
 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats
 
    do_something_at_point(float x, float y, float z);
 
 And still call it using a Vec3f via tupleof!
 
    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);
 
 as opposed to
 
    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);
 
 It's a minor thing, but it rocks.
 
 
 --bb

Thats awesome.

I think it would be cool if we had a D.algorithms newsgroup; but then 
again, I think I'd never visit this newsgroup :)

-Joel

Apr 26 2007

Georg Wrede <georg nospam.org> writes:

janderson wrote:
 Bill Baxter wrote:
 
 I've always had this dilemma in C++ when writing graphicsy methods, 
 whether a function that takes a point should take separate components 
 (float,float,float) or a vector (Vec3f), or perhaps a pointer 
 (float*).  In D there's also the option of float[3].  Or just for 
 convenience sake maybe overloads for all of the above.

 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats

    do_something_at_point(float x, float y, float z);

 And still call it using a Vec3f via tupleof!

    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);

 as opposed to

    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);

 It's a minor thing, but it rocks.

 
 I think it would be cool if we had a D.algorithms newsgroup; but then 
 again, I think I'd never visit this newsgroup :)

In six months I'l go "man there was this thing about using .tupleof when 
passing arguments, but I'm damned if I can't find it". Happens to me all 
the time.

I wonder, is there someplace where gems, nifty things, gotchas, etc. are 
collected from these newsgroups?

Apr 29 2007

janderson <askme me.com> writes:

Georg Wrede wrote:
 janderson wrote:
 Bill Baxter wrote:

 I've always had this dilemma in C++ when writing graphicsy methods, 
 whether a function that takes a point should take separate components 
 (float,float,float) or a vector (Vec3f), or perhaps a pointer 
 (float*).  In D there's also the option of float[3].  Or just for 
 convenience sake maybe overloads for all of the above.

 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats

    do_something_at_point(float x, float y, float z);

 And still call it using a Vec3f via tupleof!

    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);

 as opposed to

    do_something_at_point(
        world_origin.x,
        world_origin.y,
        world_origin.z);

 It's a minor thing, but it rocks.

 I think it would be cool if we had a D.algorithms newsgroup; but then 
 again, I think I'd never visit this newsgroup :)

 
 In six months I'l go "man there was this thing about using .tupleof when 
 passing arguments, but I'm damned if I can't find it". Happens to me all 
 the time.
 
 I wonder, is there someplace where gems, nifty things, gotchas, etc. are 
 collected from these newsgroups?
 

Start a wiki page?

Apr 29 2007

jcc7 <technocrat7 gmail.com> writes:

== Quote from Georg Wrede (georg nospam.org)'s article
 janderson wrote:
 Bill Baxter wrote:

 In six months I'l go "man there was this thing about using .tupleof
 when passing arguments, but I'm damned if I can't find it". Happens to
 me all the time.
 I wonder, is there someplace where gems, nifty things, gotchas, etc.
 are collected from these newsgroups?

In theory, I've collected some of those things in the Tutorials project
(http://www.dsource.org/projects/tutorials/wiki/), but the reality is that I
don't
have enough time to create many new pages these days (and I'd rather do other
things). So I just bookmark the cool newsgroup posts and hope that I'll be able
to
find them again in the future.

If some other people want to add cool stuff to the Tutorials project, I won't
get
it their way, though. They don't even have to ask for permission -- all they
need
is a dsource login. ;)

jcc7

Apr 30 2007

=?ISO-8859-1?Q?Lu=EDs_Marques?= <luismarques+spam gmail.com> writes:

Bill Baxter wrote:
 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats
 
    do_something_at_point(float x, float y, float z);
 
 And still call it using a Vec3f via tupleof!
 
    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);

I finally realize how useful tuples are!
Great contribution.

--
Lu�s

Apr 27 2007

Lutger <lutger.blijdestijn gmail.com> writes:

Lu�s Marques wrote:
 Bill Baxter wrote:
 I just realized today the coolness of tupleof for this kind of 
 situation.  You can make the function takes the plain floats

    do_something_at_point(float x, float y, float z);

 And still call it using a Vec3f via tupleof!

    Vec3f world_origin;
    ...
    do_something_at_point(world_origin.tupleof);

 
 I finally realize how useful tuples are!
 Great contribution.
 
 -- 
 Lu�s

Me too, thanks Bill. These are the 'little' things where D shines and 
make it so enjoyable to program in.

Apr 28 2007

D Programming

C/C++ Programming

Other

digitalmars.D - Cool thing about D, number #72