// An experiment with expression templates in D.
// With DMD 0.173  version(Expression) is massively slower than version(Other)
// 

// adapted from http://www.flipcode.com/articles/article_fastervectormath.shtml

import std.stdio : writefln;

struct vector
{
    float[3] V;

    static vector opCall( float x, float y, float z ) 
    { 
        vector V;
        V.V[0]=x; V.V[1]=y; V.V[2]=z;
        return V;
    }

    float Evaluate( int I ) { return V[I]; }

    void opCatAssign( inout vecexp_2 Exp )
    {
        for (int i=0; i<V.length; i++) {
            V[i] = Exp.Evaluate( i );
        }
    }

    version(Expression) {
        vecexp_2 opAdd(inout vector Vb) {
            return vecexp_2(*this, Vb);
        }
    }
    else {
        vector opAdd(inout vector Vb) 
            {
                return vector( V[0]+Vb.V[0], V[1]+Vb.V[1], V[2]+Vb.V[2]); 
            }
    }
}

struct sum
{
    static float Evaluate( int I, inout vector Va, inout vector Vb )
    {
        return Va.Evaluate( I ) + Vb.Evaluate( I );
    }
}
 

struct vecexp_2
{
    vector* V1;
    vector* V2;

    static vecexp_2 opCall(inout vector Va, inout vector Vb)
    //this( vector Va, vector Vb ) 
    {
        vecexp_2 V;
        V.V1= &Va ; V.V2= &Vb ; 
        return V;
    }

    float Evaluate( int I )
    { return sum.Evaluate( I, *V1, *V2 ); }
};

 
vecexp_2 opAdd( inout vector Va, inout vector Vb )
{
    assert(0, "this is never called... bummer");
    return vecexp_2( Va, Vb );
}


void main()
{
    vector a = vector(1,2,3);
    vector b = vector(3,4,5);

    vector c;
    
    for(int i=0; i<200_000; i++) {
        version(Expression) {
            c ~= a+b;
        }
        else {
            c = a+b;
        }
        a.V[0]+=1.0;
    }

    // just to make sure it's actually calculating the right result...
    version(Expression) {
        writefln("Expr version.  %f %f %f", c.V[0],c.V[1],c.V[2]);
    }
    else {
        writefln("Simple version.  %f %f %f", c.V[0],c.V[1],c.V[2]);
    }
}