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
   }
}
October 18
On 2017-08-02 21:31:19 +0000, Walter Bright said:

> https://www.reddit.com/r/programming/comments/6r6dwp/netflix_opensources_its_first_d_library_vectorflow/
> 

D got another mention in Netflix's popular tech blog: https://medium.com/netflix-techblog/machine-learning-platform-meetup-ddec090f3c17 (+meetup slides)

--Stephan

October 19
On 10/18/2017 1:49 PM, Stephan Dilly wrote:
> On 2017-08-02 21:31:19 +0000, Walter Bright said:
> 
> 
> https://www.reddit.com/r/programming/comments/6r6dwp/netflix_opensources_its_first_d_library_vectorflow/
> 
> 
> D got another mention in Netflix's popular tech blog: https://medium.com/netflix-techblog/machine-learning-platform-meetup-ddec090f3c17 (+meetup slides)
> 
> 
> --Stephan
> 

The quote:

"VectorFlow was designed for these contexts and this philosophy informed several design decisions. For example the choice of the language, D, was one such decision. The modern system language was chosen to address the goal of a single language in adhoc as well as production contexts — providing the power of C++ and the simplicity/clarity of Python."
October 19
On Tuesday, 8 August 2017 at 18:51:26 UTC, Nordlöw wrote:
> To clarify here's an incomplete snippet that should clarify:
>
> auto add(A, B)(A a, B b)

should be

auto add(A, B)(auto ref A a, auto ref B b)

Next ›   Last »
1 2