IRC channel logs

<lloda`>sorry that wasn't much help, there's no numpy-for-guile so to speak, just scattered libraries and bindings. The main utility of SRFI-4 is to interface with external libraries, if you do array math in that way you should definitely make use of it.

<lloda`>some of my half-done bindings are here https://notabug.org/lloda

<adhoc>lloda`: so SRFI-4 is really about interfacing to external libraries ?

<adhoc>is that the focus of all the SRFI ?

<lloda`>it's a container library

<lloda`>it defines vectors where the elements are memory compatible with the standard machine types

<lloda`>so I'd say that's the focus, yes

<lloda`>or the whole point, really

<adhoc>ok

<adhoc>i've done some searching for vector math libraries, but suspect that my terminology is off.

<lloda`>what kind of functions do you need? 3d vector algebra, or general linear algebra, or statistics, or...

<dsmith-work>Wednesday Greetings, Guilers

<paroneayea>davexunit: http://www.jwz.org/blog/2012/05/turtles-all-the-way-down-or-gliders-or-glider-turtles/

***michel_mno is now known as michel_mno_afk

<paroneayea>hi mark_weaver

<paroneayea>I followed your recommendation and benchmarked hash tables vs alists

<paroneayea>mark_weaver: anyway you were right! alists did consistently outperform hash tables for mappings of 5-20 elements

<paroneayea>mark_weaver: not by 50 times or so as you had guessed, but by a little bit :)

<paroneayea>(but most of the compumentation maybe was caught up in the loop itself, so)

<paroneayea>anwyay alists did outperform, as this relates to the json scheme structure discussion

<paroneayea>davexunit: ^^^

<mark_weaver>paroneayea: well, I guessed 20 times, and that was between vhashes (not normal hash tables) and alists.

<paroneayea>mark_weaver: ah right

<paroneayea>it was vhashes! :)

<paroneayea>ACTION runs the test again with that ;)

<paroneayea>mark_weaver: looks to be about 8 times faster :)

<mark_weaver>ah, okay. I guess I exaggerated :)

<mark_weaver>and surely it depends on what types the keys are

<paroneayea>one or two character strings in this case of testing

<mark_weaver>the terrible thing about hash tables is that they cause you to write code in a very imperative way.

<mark_weaver>where's alists and vhashes both support functional programming

<mark_weaver>*whereas

<paroneayea>ACTION nods

<mark_weaver>but the problem with alists and vhashes is that they don't nicely support updating existing entries. really we need purely functional HAMTs as found in clojure, and I believe that there's an implementation of them in ijp's pfd library

<mark_weaver>pfds

<mark_weaver>(pfds = purely functional data structures)

<davexunit>wingo also wrote an implementation

<davexunit>that closely models clojure's approach

<davexunit>using their idea of "transients"

<mark_weaver>ah, good. wingo's one is probably much more performant.

<davexunit>I want them in core guile

<paroneayea>I think the risk with wingo's was he read the clojure code as he wrote it and it was mostly a port of that

<mark_weaver>wingo tends to optimize things very well, whereas ijp focuses more on correctness and portability.

<paroneayea>and the clojure stuff is under the eclipse public license

<paroneayea>gpl-incompatible, for one thing

<paroneayea>so