Hiho,
thanks again for your answers!
I don't know where to start ...
@Stanislav Blinov:
I am not currently aware of the "move semantics" in D or what it
is called there. However, I am not quite sure if D does an
equally good job as C++ in determining if a value can be moved or
not. I have made some simple tests which showed me that the
swap-assignment and the move-constructor are never called in D at
code where C++ would certainly take them, instead D just copies
values which were in fact rvalues ... (Maybe I just don't get the
whole thing behind the scenes - and I am really hoping it.)
My statement that the "in" and "body" block of the assignment
operator slows down the whole code isn't true anymore. Don't know
what fixed it tough.
@bearophile:
Yeah, you are completely right - I am super confused at the
moment. I always thought that D would be much easier to learn
than C++ as all the people always say that C++ is the most
complex language. After what I have learned so far D seems to be
much more complex which isn't bad in general, but the learning
curve doesn't feel so well atm as I am mainly confused by many
things instead of getting what happens behind the scene. (e.g.
move semantics, the whole army of modifiers, immutability which
result in zero performance boost in non-paralell environments,
the fact that classes are by-ref and structs are by-val is also
confusing from time to time to be honest.)
When I started to write the C++ matrix library after I have
written the Java matrix library to get to know what both
languages can achive I have also had to start learning C++ as
well. I bought a book and after 2-3 weeks I got the concepts and
everything went as excepted and no things seemed to be hidden
behind the scenes from me, the programmer which was in fact a
nice experience when trying to optimize the code until it was
equally fast as the java code or even faster. D seems to be more
problematic when it comes to learning how to optimize the code.
To summarize, I am still a beginner and learn this language as it
has got cool, new and advanced features, it has not so many
legacy issues (like C++), it unites object orientated, functional
as well as imperative and paralell programming paradigms (still
amazed by that fact!), runs native and isn't bound to any
operating system or a huge runtime environment (java/c#). That's
why I am learning D! =)
I would love to see how much performance a D vetaran like you is
able to grab out of my codes. Just tell me where I shall upload
them and I will do so. Don't expect too much as I am still a
beginner and as this project has just started. I didn't want to
implement the whole functionality before I know how to do it with
a good result. ;-)
The matrix multiplication you have posted has some cool features
in it. I especially like the pure one with all that functional
stuff. :D
@Nick Sabalausky:
Don't be shocked at the bad performance of a beginner D
programmer. At least I am not shocked yet that my D
implementation isn't performing as well as the highly optimized
C++11 implementation or the JIT-optimized Java implementation. In
general one can not compare the results of a native compilation
optimization which shall run on different hardwares and a JIT
optimization which is able to pull out every single optimization
routine because it knows the system and all its components to
compile at.
There is also the LDC2 and the GDC which should also improve the
general performance quite a bit.
However, what is true is, that it is (at least for me) harder to
learn how to write efficient code for D than it was to learn it
for C++. And keep in mind that my Java implementation (which runs
nearly as fast as the C++ implementation) is written just to fit
for performance. I have had to do dirty things (against the
general Java mentality) in order to achive this performance.
Besides that I couldn't implement a generic solution in Java
which wasn't five to ten times slower than without generics as
generics in Java are a runtime feature. So all in all Java is
only good in performance if you don't use it as Java (purely
object oriented etc.) ... but it works! :D
@All of you:
What I have done since the last time:
I have changed my mind - matrix is now a value type. However, I
wasn't sure about this step because I planned to implement dense
and sparse matrices which could inherit from a basic matrix
implementation in thus required to be classes.
I have also removed that nasty "final struct" statement.^^
However, benchmarks stayed the same since the last post.
Hopefully I haven't forgotten to say anything important ...
Robin
