August 03
On Wednesday, 2 August 2017 at 22:56:32 UTC, Joakim wrote:
> Not doing well on HN though:
>
> https://hn.algolia.com/?query=vectorflow

HN is very sensitive to time of day when submitting. Did a new try:

https://news.ycombinator.com/item?id=14920608
August 03
On Thursday, 3 August 2017 at 14:00:31 UTC, Matt wrote:
>> Meanwhile, the blog post Laeeth gave you shows Mir doing better on matrix multiplication benchmarks than Eigen, significantly better when dealing with complex numbers.
>
> I mean by now we should all be jaded enough not to simply take toy benchmarks as gospel for which is actually fastest in a non-trivial application.

That's why I didn't make such a general claim and noted that the linked benchmarks only dealt with matrix multiplication. :P

> I don't doubt mir is really fast, though.

Yes, the benchmarks are indicative, but it's up to you come up with a benchmark that characterizes your workload better.
August 06
On Wednesday, 2 August 2017 at 22:56:32 UTC, Joakim wrote:
> On Wednesday, 2 August 2017 at 21:31:19 UTC, Walter Bright wrote:
>> https://www.reddit.com/r/programming/comments/6r6dwp/netflix_opensources_its_first_d_library_vectorflow/
>
> No. 2 liked proggit link of the day, should be no. 1 soon:
>
> https://www.reddit.com/r/programming/top/?time=day
>
> Not doing well on HN though:
>
> https://hn.algolia.com/?query=vectorflow

Top 3 for the week:

https://www.reddit.com/r/programming/top/?sort=top&t=week

People seem really enthused by this library.
August 08
On Thursday, 3 August 2017 at 04:40:05 UTC, Matt wrote:
> Also note, one of the main advantages of Eigen is the whole lazy evaluation of expressions for compound operations.
>
> I haven't dug in the source, but it's my understanding it's done through a lot of compile time C++ template hacking

Note that D provides

    __traits(isRef, Symbol)

which can be used to convenient implement lazy-evaluated expressions with free functions. Note that it cannot currently be used to check whether `this` was passed as an l-value or r-value which prevents the C++-expression-template-pattern from being used in operator overloading.

For details see: https://issues.dlang.org/show_bug.cgi?id=17734
August 08
On Tuesday, 8 August 2017 at 18:40:08 UTC, Nordlöw wrote:
> On Thursday, 3 August 2017 at 04:40:05 UTC, Matt wrote:
>> Also note, one of the main advantages of Eigen is the whole lazy evaluation of expressions for compound operations.
>>
>> I haven't dug in the source, but it's my understanding it's done through a lot of compile time C++ template hacking
>
> Note that D provides
>
>     __traits(isRef, Symbol)

To clarify here's an incomplete snippet that should clarify:

auto add(A, B)(A a, B b)
   if (isSomeArithmeticType!A &&
       isSomeArithmeticType!B)
{
   static if (__traits(isRef, a) &&
              __traits(isRef, b)) // both `a` and `b` are l-values
   {
       return a + b; // fully eager evaluation
   }
   else static if (__traits(isRef, a)) // `b` is an r-value
   {
       // `b` can incremented by `a` and returned by move (reused)
   }
   else static if (__traits(isRef, b)) // `a` is an r-value
   {
       // `a` can incremented by `b` and returned by move (reused)
   }
   else // both `a` and `b` are r-values
   {
       return Add(a,b); // delay evaluation
   }
}
Next ›   Last »
1 2