Ruby as mathematical language

[none]

Hi Ruby world.

I am attaching some pieces of an email conversation I had with Yoshiki
Tsunesada regarding his excellent work rb-gsl. I wanted to start a
discussion about what extensions would make Ruby an intuitive and
powerful math language; I think he has already laid the foundation,
but there are some important pieces that we could add, especially in
the realm of indexing and assigning to matrices (and possibly in the
realm of graphics too). Feel free to comment

**********

Yoshiki said:

As mentioned in ruby-talk, by Nobu Nakada, the C coding
in Ruby/GSL seems to be somewhat "old-fashioned". My excuse
is that I studied Ruby-C API in ruby-1.4 ages, and I just
followed a "framework" explained in a Ruby textbook
written in that days. I have not followed the current
framework, although I still don't know what is the
"franework".
Because of this, it is impossible to create a subclass
of a Ruby/GSL class in a Ruby script, while still possible
in C. The definition of the singleton method "new" in C
is the problem, but I don't know how to improve it
(for all the classes in Ruby/GSL). Sorry for inconvenience.
This problem must be improved in a future version of Ruby/GSL,
to be extensible easily from Ruby, not from C.

You can still implement your new interfaces using C API,
but you may not prefer it. If you show all your requests
you want to do in Ruby/GSL, I will code them in C. I want
to put aside the framework problem for a while, since
it is rather messy to change the coding all for the classes.
********
I replied:

I wish I was a better programmer and could implement my extensions in
ruby-gsl's C.

My extensions involve array indexing and assignment, but if you are
interested in improving the usability of rb-gsl, you might want to look
at Octave (http://www.octave.org) which is kind of a gnu matlab.
S-Plus/R (http://r-project.org) is also a good model, though not as
good in my opinion as Matlab/Octave.

It seems to me the numerical part of rb-gsl is fantastic, but I am
often faced with assembling and dissassembling large (100 x 1000)
matrices, usually composed of lots of submatrices, and rb-gsl makes
that a little hard compared to other more mathematically oriented
languages. The problem with Octave and R though, is that they are quite
limited for general programming, while Ruby is amazing. So if you want
do some big numerical work and put it online, you are stuck.

As for recoding rb-gsl in a new framework, it might be worth waiting
until Ruby 2 is out? I wonder.

I am compiling Octave right now, and I will send you some examples of
what I am interested in being able to do after I have it working.

 

[Phil Tomson]

Hi Ruby world.

I am attaching some pieces of an email conversation I had with Yoshiki
Tsunesada regarding his excellent work rb-gsl. I wanted to start a
discussion about what extensions would make Ruby an intuitive and
powerful math language; I think he has already laid the foundation,
but there are some important pieces that we could add, especially in
the realm of indexing and assigning to matrices (and possibly in the
realm of graphics too). Feel free to comment

**********

Yoshiki said:

As mentioned in ruby-talk, by Nobu Nakada, the C coding
in Ruby/GSL seems to be somewhat "old-fashioned". My excuse
is that I studied Ruby-C API in ruby-1.4 ages, and I just
followed a "framework" explained in a Ruby textbook
written in that days. I have not followed the current
framework, although I still don't know what is the
"franework".
Because of this, it is impossible to create a subclass
of a Ruby/GSL class in a Ruby script, while still possible
in C. The definition of the singleton method "new" in C
is the problem, but I don't know how to improve it
(for all the classes in Ruby/GSL). Sorry for inconvenience.
This problem must be improved in a future version of Ruby/GSL,
to be extensible easily from Ruby, not from C.

You can still implement your new interfaces using C API,
but you may not prefer it. If you show all your requests
you want to do in Ruby/GSL, I will code them in C. I want
to put aside the framework problem for a while, since
it is rather messy to change the coding all for the classes.
********
I replied:

I wish I was a better programmer and could implement my extensions in
ruby-gsl's C.

My extensions involve array indexing and assignment, but if you are
interested in improving the usability of rb-gsl, you might want to look
at Octave (http://www.octave.org) which is kind of a gnu matlab.
S-Plus/R (http://r-project.org) is also a good model, though not as
good in my opinion as Matlab/Octave.

It seems to me the numerical part of rb-gsl is fantastic, but I am
often faced with assembling and dissassembling large (100 x 1000)
matrices, usually composed of lots of submatrices, and rb-gsl makes
that a little hard compared to other more mathematically oriented
languages. The problem with Octave and R though, is that they are quite
limited for general programming, while Ruby is amazing. So if you want
do some big numerical work and put it online, you are stuck.

As for recoding rb-gsl in a new framework, it might be worth waiting
until Ruby 2 is out? I wonder.

I am compiling Octave right now, and I will send you some examples of
what I am interested in being able to do after I have it working.

Regarding your comments about rb-gsl; have you looked at narray? I've
not used rb-gsl, but it's been on my list.

As far as using Ruby as a mathematical language something like MatLab:
That would be very nice. Given that it's quite easy to create DSLs using
Ruby one would think it should be possible to create something that would
give MatLab a run for it's money (I really don't like MatLab as a
langauge). Also consider that you need to tightly integrate graphing
(perhaps through gnuplot?).

Phil

 

[Ara.T.Howard]

Hi Ruby world.

I am attaching some pieces of an email conversation I had with Yoshiki
Tsunesada regarding his excellent work rb-gsl. I wanted to start a
discussion about what extensions would make Ruby an intuitive and
powerful math language; I think he has already laid the foundation,
but there are some important pieces that we could add, especially in
the realm of indexing and assigning to matrices (and possibly in the
realm of graphics too). Feel free to comment

**********

Yoshiki said:

As mentioned in ruby-talk, by Nobu Nakada, the C coding
in Ruby/GSL seems to be somewhat "old-fashioned". My excuse
is that I studied Ruby-C API in ruby-1.4 ages, and I just
followed a "framework" explained in a Ruby textbook
written in that days. I have not followed the current
framework, although I still don't know what is the
"franework".
Because of this, it is impossible to create a subclass
of a Ruby/GSL class in a Ruby script, while still possible
in C. The definition of the singleton method "new" in C
is the problem, but I don't know how to improve it
(for all the classes in Ruby/GSL). Sorry for inconvenience.
This problem must be improved in a future version of Ruby/GSL,
to be extensible easily from Ruby, not from C.

You can still implement your new interfaces using C API,
but you may not prefer it. If you show all your requests
you want to do in Ruby/GSL, I will code them in C. I want
to put aside the framework problem for a while, since
it is rather messy to change the coding all for the classes.
********
I replied:

I wish I was a better programmer and could implement my extensions in
ruby-gsl's C.

My extensions involve array indexing and assignment, but if you are
interested in improving the usability of rb-gsl, you might want to look
at Octave (http://www.octave.org) which is kind of a gnu matlab.
S-Plus/R (http://r-project.org) is also a good model, though not as
good in my opinion as Matlab/Octave.

It seems to me the numerical part of rb-gsl is fantastic, but I am
often faced with assembling and dissassembling large (100 x 1000)
matrices, usually composed of lots of submatrices, and rb-gsl makes
that a little hard compared to other more mathematically oriented
languages. The problem with Octave and R though, is that they are quite
limited for general programming, while Ruby is amazing. So if you want
do some big numerical work and put it online, you are stuck.

As for recoding rb-gsl in a new framework, it might be worth waiting
until Ruby 2 is out? I wonder.

I am compiling Octave right now, and I will send you some examples of
what I am interested in being able to do after I have it working.

have you looked at narray? it's quite good at decomposing matrices. also,
this kind of dicsussion would be nice to have posted at
http://sciruby.codeforpeople.com if you're up to it.

cheers.

-a
--
===============================================================================
| email :: ara [dot] t [dot] howard [at] noaa [dot] gov
| phone :: 303.497.6469
| My religion is very simple. My religion is kindness.
| --Tenzin Gyatso
===============================================================================

 

[none]

Regarding Narray, it seems kind of cool, but lacking in real
mathematical sophistication. I think it would be better to extend
rb-gsl to make composing matrices easier and thus keep the excellent
linear algebra facilities. Really, I think Narray and rb-gsl have a
lot of redundancy and I really don't like bouncing between the two of
them.

Regarding graphics, matplotlib for python rocks, I wonder if it can be
ported....

The basics are all around, the problem is designing an intuitive one
stop shop that is really usable. Being able to hack something out of
gnuplot is not the same as having a well put together
framework/library....

 

[Ara.T.Howard]

Regarding Narray, it seems kind of cool, but lacking in real
mathematical sophistication. I think it would be better to extend
rb-gsl to make composing matrices easier and thus keep the excellent
linear algebra facilities. Really, I think Narray and rb-gsl have a
lot of redundancy and I really don't like bouncing between the two of
them.

can you give an example of something you'd like to do but can't?

Regarding graphics, matplotlib for python rocks, I wonder if it can be
ported....

narray's are easily plotted or viewed as images.

The basics are all around, the problem is designing an intuitive one stop
shop that is really usable. Being able to hack something out of gnuplot is
not the same as having a well put together framework/library....

narray takes a bit of getting used to - but there is really a tight
integration. check out

http://www.gfd-dennou.org/arch/ruby/
http://www.ir.isas.ac.jp/~masa/ruby/gsl/

there's alot. not much in english - something i'm working to remedy in

http://sciruby.codeforpeople.com/sr.cgi/TheScientificRubyProgrammingBook

cheers.

-a
--
===============================================================================
| email :: ara [dot] t [dot] howard [at] noaa [dot] gov
| phone :: 303.497.6469
| My religion is very simple. My religion is kindness.
| --Tenzin Gyatso
===============================================================================

 

[Steven Jenkins]

One option would be to reimplement rb-gsl using SWIG. GSL is pretty big,
but wrapping it with SWIG might not be too hard if its interfaces are
implemented using a small number of types. You have to write two or
three typemaps for each type, and SWIG does the rest.

I've wrapped two libraries with SWIG. and while I don't consider myself
an expert, I have learned a few things. I'd be willing to help get
things kicked off.

One thing to bear in mind, however. Wrapping (whether with SWIG or not)
often requires copying input and output parameters. That's usually not a
big deal, but you might take a substantial performance hit if you're
passing large numbers of large arrays through a wrapper.

[snip]

As far as using Ruby as a mathematical language something like MatLab:
That would be very nice. Given that it's quite easy to create DSLs using
Ruby one would think it should be possible to create something that would
give MatLab a run for it's money (I really don't like MatLab as a
langauge). Also consider that you need to tightly integrate graphing
(perhaps through gnuplot?).

Much of the value of Matlab is not the language itself, but the large
number of libraries available for specialized applications like control
systems and signal processing. That's much harder to replace than the
underlying execution engine. (Which is, of course, part of the reason
Fortran is still with us.)

Steve

 

[Paulo Jabardo]

I'm new to ruby and I intend to use ruby to do
scientific data acquisition and a little processing. I
am very interested in mathematical libraries for ruby.

I just took looked at narray and it seems very nice. I
think we should be careful with gsl's matrix
capabilities. It was designed to provide dynamic
matrices to C. In dynamic labguages like ruby we could
do things differently providing much more flexibility.
With a contiguous block of memory it should not be
very difficult to write a thin interface so that
narray, for instance, could be used in gsl's linear
algebra procedures (if I remember correctly gsl
provides something like that - generate a matrix from
a memory block).=20

For ruby to be used as mathematical language I think
it is important to standardize on a single array
library that uses ruby's qualities to its full extent

Mathplotlib really looks amazing. If porting is
possible ruby would have a really nice graphics
capabilities.

Paulo

On Fri, 8 Jul 2005, none wrote:
=20

Regarding Narray, it seems kind of cool, but lacking in real
mathematical sophistication. I think it would be better to extend
rb-gsl to make composing matrices easier and thus keep the excellent
linear algebra facilities. Really, I think Narray and rb-gsl have a
lot of redundancy and I really don't like bouncing between the two of
them.

=20
can you give an example of something you'd like to
do but can't?
=20

Regarding graphics, matplotlib for python rocks, I wonder if it can be
ported....

=20
narray's are easily plotted or viewed as images.
=20

The basics are all around, the problem is

designing an intuitive one stop

shop that is really usable. Being able to hack something out of gnuplot is
not the same as having a well put together

framework/library....
=20
narray takes a bit of getting used to - but there is
really a tight
integration. check out
=20
http://www.gfd-dennou.org/arch/ruby/
http://www.ir.isas.ac.jp/~masa/ruby/gsl/
=20
there's alot. not much in english - something i'm
working to remedy in
=20
=20
http://sciruby.codeforpeople.com/sr.cgi/TheScientificRubyProgrammingBook

=20
cheers.
=20
-a
--=20

=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
| email :: ara [dot] t [dot] howard [at] noaa [dot]
gov
| phone :: 303.497.6469
| My religion is very simple. My religion is
kindness.
| --Tenzin Gyatso
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
=20
=20
=20

__________________________________________________
Converse com seus amigos em tempo real com o Yahoo! Messenger=20
http://br.download.yahoo.com/messenger/=20

 

[none]

How do you get the singular value decomposition of a matrix in Narray
into a [u,x,v] triple of matrices? Then I want to grab the first
column of u (u,1) in matlab).

I am also interested in stacking a bunch of data matrices with various
lags:

c = column dimension of m
stacked_m = [m, 1:c-2); m, 2:c-1); m,3:c)]

Finally, just for grins, I want to assign 1 to all the elements of a
matrix if which are less than 1:

m(m<1) = 1

I think there is a *lot* of work, in various bits and pieces. (And I
don't write Japanese, unfortunately.) However, it seems to be all over
the place. (I was never very fond of the CPAN haphazard approach to
"library" development.)

I don't want to complain--I would be quite happy to help with a
project. I just think we need a push to come up with a use-case based
integration of all the tools, like scipy in Python (really like scipy +
matplotlib), all in one coherent package.

 

[William Morgan]

Excerpts from none's mail of 7 Jul 2005 (EDT):

Regarding Narray, it seems kind of cool, but lacking in real
mathematical sophistication. I think it would be better to extend
rb-gsl to make composing matrices easier and thus keep the excellent
linear algebra facilities. Really, I think Narray and rb-gsl have a
lot of redundancy and I really don't like bouncing between the two of
them.

If it's a matter of adding matrix composition capabilities, you probably
want add that to the GSL. Presumably Ruby would be the wrong place to
put the computationally intensive aspect of your operations.

Regarding graphics, matplotlib for python rocks, I wonder if it can be
ported....

There is mrplot in Ruby, which I haven't used, but the screenshots look
very decent: http://rubyforge.org/projects/mrplot/.

The basics are all around, the problem is designing an intuitive one
stop shop that is really usable. Being able to hack something out of
gnuplot is not the same as having a well put together
framework/library....

As someone who uses the living hell that is R on a regular basis (though
not for any kind of linear algebra), I would give my left nut to be able
to use Ruby in its stead. But as Steve Jenkins pointed out, the real
value in Octave and R is the huge libraries behind them, not the
languages themselves.

Still, you've got to start somewhere. I'm very interested in this as
well.

 

[Paulo Jabardo]

One option would be to reimplement rb-gsl using
SWIG. GSL is pretty big,=20
but wrapping it with SWIG might not be too hard if
its interfaces are=20
implemented using a small number of types. You have
to write two or=20
three typemaps for each type, and SWIG does the
rest.

ruby-gsl already wraps most of gsl. From what I've
seen on this list, the problem is the Vector and
Matrix libraries, even though they seem to work fine
in ruby-gsl even though it does not use every OO
concept available to ruby users.

=20

I've wrapped two libraries with SWIG. and while I
don't consider myself=20
an expert, I have learned a few things. I'd be
willing to help get=20
things kicked off.
=20
One thing to bear in mind, however. Wrapping
(whether with SWIG or not)=20
often requires copying input and output parameters.
That's usually not a=20
big deal, but you might take a substantial
performance hit if you're=20
passing large numbers of large arrays through a
wrapper.

This really could hurt in many situations.

=20

Much of the value of Matlab is not the language
itself, but the large=20
number of libraries available for specialized
applications like control=20
systems and signal processing. That's much harder to
replace than the=20
underlying execution engine. (Which is, of course,
part of the reason=20
Fortran is still with us.)

You hit the nail! But remember that now there are many
Free/OS libraries available. But even if we wrapped
and developped many numerical libraries I don't think
ruby (or python) would be the ideal language for
computation. R/S-PLUS, for instance, were designed for
this purpose alone and I think it is a great language.
Even matlab has a language appropriate to numerical
computation (I don't like matlab's language).

Good graphics capabilities is very important for a
mathematical environment to succeed.

Paulo





=09
=09
=09
_______________________________________________________=20
Yahoo! Acesso Gr=E1tis - Internet r=E1pida e gr=E1tis.=20
Instale o discador agora! http://br.acesso.yahoo.com/

 

[William Morgan]

Excerpts from none's mail of 7 Jul 2005 (EDT):

I think there is a *lot* of work, in various bits and pieces. (And I
don't write Japanese, unfortunately.) However, it seems to be all
over the place. (I was never very fond of the CPAN haphazard approach
to "library" development.)

I don't want to complain--I would be quite happy to help with a
project. I just think we need a push to come up with a use-case based
integration of all the tools, like scipy in Python (really like scipy
+ matplotlib), all in one coherent package.

I too think the time is ripe for this. With a really good data model and
a really good plotting library, and GSL/NArray/other/combination thereof
in the background, Ruby could take over the (scientific) world.

A good starting point is Ara's SciRuby wiki
(http://sciruby.codeforpeople.com), particularly
http://sciruby.codeforpeople.com/sr.cgi/InterestingProjects

 

[Masahiro TANAKA]

How do you get the singular value decomposition of a matrix in Narray
into a [u,x,v] triple of matrices? Then I want to grab the first
column of u (u,1) in matlab).

NArray itself does not support singular value decomposition.
Combination with Ruby/GSL will help.

I am also interested in stacking a bunch of data matrices with various
lags:

c = column dimension of m
stacked_m = [m, 1:c-2); m, 2:c-1); m,3:c)]

This seems to be written for NArray as:
stacked_m = m[true, [0..c-3,1..c-2,2..c-1]]

Finally, just for grins, I want to assign 1 to all the elements of a
matrix if which are less than 1:

m(m<1) = 1

m[m.lt(1)] = 1

masa

 

[none]

Has anybody done any collaborative design? I am not sure how we might
proceed from here. (I don't think trusting something to just appear
on a wiki is a good plan, though the wiki looks like a great tool.)

I think there are a lot of really bright people willing to help if we
can focus the effort in an integrated way. Something a la Python's PEP
process, perhaps (no more alliteration!), or an RFC thing. It might be
best to start from a model--implementing it might be the easy part,
given the amazing amount of talent available.

I think we *need* to get away from thinking about what libraries are
available and how to cobble them together. Instead, we need to
*imagine* and *specify* what we would want in a perfect scientific
language.

Also, as long as the base algorithms and graphics are there (linear
algebra, etc), I think folks will add libraries all over the place. GSL
is a great resource for example, maybe the PARI libraries, and ??

Rambling over for the moment...

 

[Ara.T.Howard]

How do you get the singular value decomposition of a matrix in Narray
into a [u,x,v] triple of matrices?

i'll leave this one as an exercise because i'm pressed for time and it sounds
like math. ;-)

Then I want to grab the first column of u (u,1) in matlab).

harp:~ > cat a.rb
require 'narray'

u = NArray::int 2, 3
u[true, 0] = 42
c = u[true, 0]
p c

harp:~ > ruby a.rb
NArray.int(2):
[ 42, 42 ]

I am also interested in stacking a bunch of data matrices with various
lags:

c = column dimension of m
stacked_m = [m, 1:c-2); m, 2:c-1); m,3:c)]

not sure exactly what you are looking for here, but it can easily be done:

harp:~ > cat a.rb
require 'narray'

c = 3
r = 2
m = NArray::int c, r
s = true

m[s, 0] = [0,1,2]
m[s, 1] = [3,4,5]
p m

stacked_m = NArray::to_na [ m[0..c-2, s], m[1..c-1, s] ]
p stacked_m

harp:~ > ruby a.rb
NArray.int(3,2):
[ [ 0, 1, 2 ],
[ 3, 4, 5 ] ]
NArray.int(2,2,2):
[ [ [ 0, 1 ],
[ 3, 4 ] ],
[ [ 1, 2 ],
[ 4, 5 ] ] ]

Finally, just for grins, I want to assign 1 to all the elements of a
matrix if which are less than 1:

m(m<1) = 1

again this is trivial:

harp:~ > cat a.rb
require 'narray'
na = NArray::to_na [42, -1, -42, 0]
na[na < 1] = 1
p na

harp:~ > ruby a.rb
NArray.int(4):
[ 42, 1, 1, 1 ]

I think there is a *lot* of work, in various bits and pieces. (And I don't
write Japanese, unfortunately.)
english:

http://www.ir.isas.ac.jp/~masa/ruby/index-e.html
http://www.ir.isas.ac.jp/~masa/ruby/na/SPEC.en


However, it seems to be all over
the place. (I was never very fond of the CPAN haphazard approach to
"library" development.)

it's either here:

http://raa.ruby-lang.org/

or here:

http://rubyforge.org/

I don't want to complain--I would be quite happy to help with a
project. I just think we need a push to come up with a use-case based
integration of all the tools, like scipy in Python (really like scipy +
matplotlib), all in one coherent package.

here:

http://www.gfd-dennou.org/library/ruby/index.htm

all there stuff can be found by:

http://raa.ruby-lang.org/search.rhtml?search=dennou

hth.

-a
--
===============================================================================
| email :: ara [dot] t [dot] howard [at] noaa [dot] gov
| phone :: 303.497.6469
| My religion is very simple. My religion is kindness.
| --Tenzin Gyatso
===============================================================================

 

[Steven Jenkins]

ruby-gsl already wraps most of gsl. From what I've
seen on this list, the problem is the Vector and
Matrix libraries, even though they seem to work fine
in ruby-gsl even though it does not use every OO
concept available to ruby users.

My point is that wrappers generated by SWIG do not have this limitation.
In particular, you can subclass the generated classes that correspond to
structs in the underlying C interface, which was Webb's original issue.

Steve

 

[none]

That is cool about narray--I couldn't figure out from the docs how to
do that.

Regarding the other links--I guess I have a problem with that approach.
In R or Matlab (which have huge limitations), you know that you can
sit down, open a session, grab some big matrices, compose them, do some
nifty math, make some publishable plots, and save everything before you
leave. You don't worry about whether Ruby Gnu plot is going to work
with some other library you downloaded to try to read CDF files and
whether you will have the linear algebra tools you need.

I also realize there is a big world of Ruby in Japanese that I can't
really tap into.

In light of all my b*ing, does it seem like your wiki would be a good
place to start a Scientific Ruby Environment discussion area?

W

 

[Ara.T.Howard]

That is cool about narray--I couldn't figure out from the docs how to do
that.

it took me a little while too..

Regarding the other links--I guess I have a problem with that approach. In
R or Matlab (which have huge limitations), you know that you can sit down,
open a session, grab some big matrices, compose them, do some nifty math,
make some publishable plots, and save everything before you leave. You
don't worry about whether Ruby Gnu plot is going to work with some other
library you downloaded to try to read CDF files and whether you will have
the linear algebra tools you need.

this is totally understandable. i was just pointing out that narray is a good
foundation. it already supports graphics and some other neat stuff (it's
integrated with netcdf support for example) - added math routines would be
really easy i think - but would require a little c.

I also realize there is a big world of Ruby in Japanese that I can't really
tap into.

yeah... some translators on the list would be nice...

In light of all my b*ing, does it seem like your wiki would be a good
place to start a Scientific Ruby Environment discussion area?

absolutely - it's there as a community resource. that wiki is pretty
powerfull: it allows things such as subpages, file uploads (nifty for
diagrams) and acls. ping me offline and i'll add you as a member. the way i
have it setup members can add new members. in this way i hope to gather
meaningful contributions with minimal risk of spam - since i have zero time to
admin.

any ideas about, or uses of, the wiki are welcome. you needn't ask - just
dive in ;-)

cheers.

-a
--
===============================================================================
| email :: ara [dot] t [dot] howard [at] noaa [dot] gov
| phone :: 303.497.6469
| My religion is very simple. My religion is kindness.
| --Tenzin Gyatso
===============================================================================

 

[William Morgan]

Excerpts from none's mail of 7 Jul 2005 (EDT):

I am not sure how we might proceed from here.

Here's my suggestion. Let's spend a little time fleshing things out on
Ara's wiki. When we get to a reasonable state, let's jump right in to
RubyForge. Write some very basic high-level code, to be fleshed out
later, push design specifics out to the mailing list and start working
it all out.

I think the trick is to get something simple working as soon as
possible. Then people have something tangible and it's easy to get
involved and excited.

I think we *need* to get away from thinking about what libraries are
available and how to cobble them together. Instead, we need to
*imagine* and *specify* what we would want in a perfect scientific
language.

I agree completely. Forget about the specifics of GSL and Narray and
MRplot and everything else for a moment and just focus the ideal
interface.

It's also important at this point to get as many different use cases in
our heads as possible. I'm coming from a dataframe-oriented, stats-heavy
R perspective; you're doing linear algebra... are people interested in
the symbolic computation aspects of Octave? Other things?

What do you think?

 

[none]

I have an email to Ara to add me as an editor. I think you are right
about getting something running. If we wrap a whole bunch of
libraries, it might be slow, but a design is what we are after, and
optimization can happen later.

While I am thinking about it, here is a somewhat random brain dump of
everything I would like to see:

Symbolic
--Solving symbolic algebra
--Applying "normal" mathematics to data as blocks

Data:
--Data acquisition (netCDF, internet, SQL, native, etc)
--Data storage
--Session persistence
--Concurrent access
--Data communication
--Views of data--I prefer as matrices with sparse extra info, but in R
you can have data frames with all sorts of weird types in the rows
("ordered factors")
--SQL
--Data organization while working (hierarchies, stacks a la HP
calculators, that R command where you say "I am working on dataframe x
now", etc, setting up contexts in a session to make working easier)
--Speed and space considerations
--Views and handles--maybe pass through to persistent storage
sometimes?

Math
--Numerical routines (linear algebra is often the base, but
minimization, etc)
--.... I show my lack of more than a B.A. in math here...
--Pay attention to various branches, from statisticians to number
theorists
--Units! (I hate units!)

Visualization
--2-d plots, but with many plots on a page, many lines or whatever on a
plot
--3-d
--Fancy stuff like VTK, or ???
--Slightly specialized applications (viewing directed graphs, etc)

Other
--Geographic stuff
--Learning curve: starting should be easy, progressing should be linear
--Integration with version control

Output
--Printable graphics--latex, pdfs, etc
--Integrating text with graphics nicely
--Integrating our text with other programs


Playing nice with the rest of the world
--Internet
--Databases
--Metadata, central who knows what
--Instrument input

Interaction modes/stuff
--Interactive session
--Batch
--Server
--Hooks

Models (other languages)
--Octave/Matlab
--R/Splus
--IDL
--Connection based visualization languages (OpenDX)
--Connection based processing (ArcView Model Builder)
--Verilog
--ML/Prolog pattern matching etc (useful?)
--Erlang message passing (just brainstorming, remember...)

 

[none]

Also--perhaps using an event based interpreter... again, just
brainstorming. But it works great for Tk.