Anyone come up with some cool algorithms/templates for D lately?

[Bill Baxter]

janderson wrote:
> In the past people have posted these cool algorithms/templates they 
> figured out how to do in some neat way with D.  Things like wow, this 
> would take INF+ lines in C++ but I can do it in 2 in D.   This seems to 
> have died down a bit.   I always found these topics most interesting.
> 
> So I'm requesting people to post "cool stuff" they figured out how to do 
> in D.

I'm still flabbergasted by the cool things you can do inside 
fixed-length matrix/vector templates.

For instance (this is all from my matrix/vector classes in OpenMesh/D 
which are basically a complete rewrite of the original C++ versions)

struct MatrixT(T, int M, int N)
{
     alias T Scalar;

     union {
         Scalar[M*N] values_ = void;
         static if(M<=10 && N<=10) {
             mixin(_gen_elements!(M,N)("Scalar"));
         }
     }
}

// Generate the elements m00,m01,m02... elements
// For matrices with dimensions < 10 x 10 only.
private string _gen_elements(int M, int N)(string type) {
     static assert(M<=10);
     static assert(N<=10);
     char[] Num = "0123456789";
     string ret;
     for(int col=0; col<N; ++col) {
         ret ~= type ~ " ";
         for (int row=0; row<M; row++) {
             ret ~= "m" ~ Num[row] ~ Num[col];
             if (row!=M-1) ret ~=  ", ";
         }
         ret ~= ";\n";
     }
     return ret;
}

This creates aliases to each element of the matrix of the form m00, m01, 
m02, but only if the matrix is small enough.  I have no idea how you'd 
do that in C++.  I don't think it's really possible.


Here's another -- generating the unrolled code for multiplying two 
matrices together:

/// Multiply MxN matrix time NxP matrix
void mat_mult_ret(T,int M,int N,int P)(
     /*const*/ref MatrixT!(T,M,N) A,
     /*const*/ref MatrixT!(T,N,P) B,
     inout MatrixT!(T,M,P) ret)
{
     with(ret) {
         mixin(_gen_mat_mult_body!(M,N,P)("A","B"));
     }
}

private string _gen_mat_mult_body(int M, int N, int P)(string A, string B)
{
     string ret;
     for (int row=0; row<M; ++row) {
         for(int col=0; col<P; ++col) {
             ret ~= "        ";
             ret ~= "values_["~ctfe_itoa(col*M+row)~"] = ";
             for(int jj; jj<N; ++jj) {
                 string JJ = ctfe_itoa(jj);
                 string iA = ctfe_itoa( row+jj *M );
                 string iB = ctfe_itoa( jj +col*N );
                 ret ~= A ~ ".values_["~iA~"]*"~B~".values_["~iB~"]";
                 if (jj != N-1) { ret ~= " + "; }
                 else { ret ~= ";\n"; }
             }
         }
         ret ~= "\n";
     }
     return ret;
}


Wow.  The code generating function basically just looks like a standard 
triply-nested matrix multiply, but instead of doing multiplies it just 
splits out code that implements multiplies.

I think that's pretty sweet.

--bb