>> With regard to NumPy, especially the stuff about the "strides" (whatever >> that is) in the data buffer of a NumPy array and how what changes when >> creating a view and changing indices (For example I cannot imagine a >> single reason, why the ordering of how one writes the indices would >> matter, except for human readability?) … If I need to keep track of that >> … Let's just say I dislike working on a low level with a lot of >> pointers, addresses and segfaults ; )
So I think there are three sides to this. 1) the array type, 2) using the array type in Scheme, 3) interfacing with C or Fortran (or whavever). 1) Guile already has a multidimensional array type with strides and all that. Has had it forever. The base library (array-map! etc) is low level and doesn't do much, and the implementation has some cruft, but the type is there, it's fairly simple stuff and and there's nothing fundamentally wrong with it. Should be safe too. People love to write their own matrix type on top of vectors or bytevectors or even lists. Sometimes there's a good reason for that but often there isn't. 2) IMO the only real flaw with the current Guile array type is that it's all in C so the array descriptors are opaque to Scheme, and the compiler isn't smart enough yet to remove the type dispatches that result from the base library being type generic [*]. This is an actual problem when you do everything in Scheme, but it's just the difference between things being slow or very slow. AFAIK this isn't any worse than what you get in Numpy. If you operate with arrays ‘in the large’ (manipulating strides, etc.) then everything is fast. Of course Numpy gives you a ton of ready made functions that would be nice to have in Guile as well [**]. 3) If you're using Guile arrays as an interface to C or Fortran, the above doesn't matter. Neither C nor Fortran (<90) have a standard way of passing multidimensional arrays to a function, so you are using pointers whether you like it or not. Every library has its own particular way of passing strides and its own quirks about what strides they accept, etc. You have to deal with that one way or another. Might as well have a nice, already available array type on the Scheme side! [*] [**] I have started efforts to fix these two problems (both fizzled due to lack of time, although I think they contain some valid stuff — e.g. if you need to slice arrays, I prefer from and amend! in guile-ploy to the Numpy mess). I'd be happy to contribute to a common effort if anyone else is interested. PS. Does anyone want to collaborate in wrapping HDF5? I've looked into mwette's FFI helper for like two seconds but I couldn't get it to work.
