Optimize my code =)

[bearophile]

Robin:

> the existance of move semantics in C++ and is one of the 
> coolest features since C++11 which increased and simplified 
> codes in many cases enormously for value types just as structs 
> in D.

I guess Andrei doesn't agree with you (and move semantics in 
C++11 is quite hard to understand).


> I also gave scoped imports a try and hoped that they were able 
> to reduce my executable file and perhaps increase the 
> performance of my program, none of which was true -> confused. 
> Instead I now have more lines of code and do not see instantly 
> what dependencies the module as itself has. So what is the 
> point in scoped imports?

Scoped imports in general can't increase performance. Their main 
point is to avoid importing modules that are needed only by 
templated code. So if you don't instantiate the template, the 
liker works less and the binary is usually smaller (no 
moduleinfo, etc).


> Another weird thing is that the result ~= text(tabStr, this[r, 
> c]) in the toString method is much slower than the two 
> following lines of code:
>
> result ~= tabStr;
> result ~= to!string(this[r, c]);
>
> Does anybody have an answer to this?

It doesn't look too much weird. In the first case you are 
allocating and creating larger strings. But I don't think matrix 
printing is a bottleneck in a program.


> - Then I have finally found out the optimizing commands for the 
> DMD

This is a small but common problem. Perhaps worth fixing.


> There are still many ways to further improve the performance. 
> For examply by using LDC

Latest stable and unstable versions of LDC2, try it:
https://github.com/ldc-developers/ldc/releases/tag/v0.12.1
https://github.com/ldc-developers/ldc/releases/tag/v0.13.0-alpha1


> on certain hardwares, paralellism and perhaps by implementing 
> COW with no GC dependencies. And of course I may miss many 
> other possible optimization features of D.

Matrix multiplication can be improved a lot tiling the matrix (or 
better using a cache oblivious algorithm), using SSE/AVX2, using 
multiple cores, etc. As starting point you can try to use 
std.parallelism. It could speed up your code on 4 cores with a 
very limited amount of added code.

Bye,
bearophile