Sorry for all the emails--I think this is the last. The final version of tuple
utils, complete with the rotation matrix example:
dispu=:3 :0
if. 0...@$y do. ":y
elseif. 1=#y do. dispd {.y
elseif. do. '()' surround ((, ','&,)/ dispd"_1 y) end.
)
dispd=:3 :0
if. 0...@$y do. ":y
elseif. 1=#y do. dispu {.y
elseif. do. '[]' surround ((, ','&,)/ dispu"_1 y) end.
)
disptuple=:' ' -.~ dispd
multiply=: 4 :0
assert. 0 0-: 2| x ,&(#...@$) y
if. 0 e. x ,&(#...@$) y do. x*y NB. scalar multiplication
elseif. x (-:|.)&(2{.$) y NB. contraction
do. x (+/^:2 @:(multiply"_2) 1 0&|:) y
elseif. do. x multiply"_ _2 y NB. non-contraction
end.
)
NB. *****Example*****
disptuple rot=.(2 1 1 2$ 2 1 _1 2)
[(2,1),(_1,2)]
disptuple r=.rot (*...@[ * |@[ o. ]) th=.0.25p1 NB. 45 degree rotation matrix
[(0.707107,0.707107),(_0.707107,0.707107)]
disptuple v=.,:1 0 NB. unit vector in the x direction
(1,0)
disptuple r multiply v
(0.707107,0.707107)
disptuple r multiply r NB. two 45 degree rotations -> one 90 degree rotation
[(2.22045e_16,1),(_1,2.22045e_16)]
Marshall
-----Original Message-----
From: Marshall Lochbaum [mailto:[email protected]]
Sent: Friday, December 10, 2010 7:57 PM
To: 'Programming forum'
Subject: RE: [Jprogramming] Verbs that take verbs as arguments (pt 2)
Now I can present a rather nice tuple display that conforms with the standards
in SICM:
dispu=:3 :0
if. 0...@$y do. ":y
elseif. 1=#y do. dispd {.y
elseif. do. '()' surround ((, ','&,)/ dispd"_1 y) end.
)
dispd=:3 :0
if. 0...@$y do. ":y
elseif. 1=#y do. dispu {.y
elseif. do. '[]' surround ((, ','&,)/ dispu"_1 y) end.
)
disptuple=:dispd
This gives:
u=.,:1 2 3
d=.,.1 2 3
s=.2
disptuple@> u;d;s
(1,2,3)
[1,2,3]
2
disptuple u multiply u
((1,2,3),(2,4,6),(3,6,9))
You can also try
disptu...@multiply&.>/~ u;d;s
but I would rather not post boxes in an email.
Marshall
-----Original Message-----
From: Marshall Lochbaum [mailto:[email protected]]
Sent: Friday, December 10, 2010 7:33 PM
To: 'Programming forum'
Subject: RE: [Jprogramming] Verbs that take verbs as arguments (pt 2)
A fully recursive version is given below:
multiply=:4 :0 "2
assert. 0 0-: 2| x ,&(#...@$) y
if. 0 e. x ,&(#...@$) y do. x*y
elseif. x ~:&(1 i. $) y do. x (+/@,@:(multiply"_2) |:) y elseif. do. x
multiply"_2 _ y end.
)
Marshall
-----Original Message-----
From: Marshall Lochbaum [mailto:[email protected]]
Sent: Friday, December 10, 2010 7:29 PM
To: 'Programming forum'
Subject: RE: [Jprogramming] Verbs that take verbs as arguments (pt 2)
My best attempt for up and down tuples is to represent up tuples as columns and
down tuples as rows (and scalars as scalars).
Thus an up tuple has shape (1 n) and a down tuple has shape (n 1) .
This gives, with many conditionals, a multiplication routine:
multiply=:4 :0 "2
assert. 0 0-: 2| x ,&(#...@$) y NB. reject odd ranks--these
cannot be tuples
if. 0 e. x ,&(#...@$) y do. x*y NB. one of x or y is a scalar
elseif. x ~:&(1 i. $) y do. x (+/@,@:* |:) y NB. up*down or down*up
elseif. do. x */ y end. NB. up*up or down*down
)
Which gives all the correct results--try
u=. ,: 1 2 3
d=. ,. 1 2 3
s=. 2
multiply&.>/ u;d;s
One note is that this definition does not employ recursion as specified--it
cannot handle nested tuples.
Marshall
-----Original Message-----
From: [email protected]
[mailto:[email protected]] On Behalf Of Alex Gian
Sent: Friday, December 10, 2010 6:55 AM
To: Programming forum
Subject: Re: [Jprogramming] Verbs that take verbs as arguments (pt 2)
Thanks very much for that Marshall and Raul,
I will go over it in detail!
BTW,
If any Jers want to understand Wisdom & Sussman's approach to Classical
Mechanics, using a clear unambiguous modern functional notation (=> computer
executable) there is also a good introductory paper:
"The Role of Programming in the formulation of Ideas"
http://dspace.mit.edu/handle/1721.1/6707
Also if you have got SICM, and want a brief intro into their model look at
Chapter 8 (our notation) so that you don't have to glean the computational
approach from reading the book.
http://mitpress.mit.edu/sicm/book-Z-H-79.html#%_chap_8
Finally, what I think will be an interesting J challenge (when I get round to
it) is the implementation of their tuples. The text uses two types "up"
and "down" tuples, with up tuples equivalent to regular vectors, while down
tuples correspond to duals. There is an interesting contraction possible when
tuples are of the same length and opposite type.
You can get a taste of this from the MIT-scheme "scmutils" manual In the
section on "Up tuples and Down tuples".
http://groups.csail.mit.edu/mac/users/gjs/6946/refman.txt (about 10 screens
down)
My apologies for going a bit off-topic, but this stuff along with some
practical applications will be my J playing field for the foreseeable...
On Thu, 2010-12-09 at 22:57 -0500, Marshall Lochbaum wrote:
> Having taken an incredibly shallow look at the first few pages of
> SICM, I will now highly recommend to you the conjunction
>
> T=: 2 : '] , u d. (i.<:n)'
>
> where (u T n) gives the first n components of the "local tuple" of the
> function u. It may then be applied to a time t to obtain the actual value
> of this vector. So:
>
> *: T 4
> ] , (*: , +: , 2"0)"0
>
> For the record, I am not entirely sure how this works with vector outputs
> (or inputs, but these seem less important).
>
> Marshall
>
> -----Original Message-----
> From: [email protected]
> [mailto:[email protected]] On Behalf Of Alex Gian
> Sent: Thursday, December 09, 2010 7:53 PM
> To: Programming forum
> Subject: [Jprogramming] Verbs that take verbs as arguments (pt 2)
>
> Sorry to plague you with more newbie questions, but I'm a little pressed
> for time here.
>
> OK, for anyone familiar with Scheme/Lisp/λ-calculus etc, here's what I'm
> trying to do:
>
> (define (gamma q)
> (lambda(t)
> (list t (q t) ((d1 q) t)))
>
>
> In other words, I want to pass a monadic verb (call it 'q') to the
> 'gamma' verb/function and I want the result to be a monadic
> verb/function that will accept a value ('t') and return a three elem
> array of rank 1 t, q t, q D.1 t
>
> IOW, something like
> testfunc =. gamma @ q
> testfunc 1.1
> 1.1 (q 1.1) ((q D.1) 1.1)
>
> (In case anyone wonders why the weird questions, I am working through
> Sussman & Wisdom's SICM, and would like to try the code in parallel in
> J to compare the two notations.)
>
> I suppose I am really trying to figure how J deals with anonymous
> functions. Where I am getting stuck is the scoping of the values of y
> (and x) in explicit definitions.
>
> I /could/ do it as a dyad, but
> gamma=: dyad : 'y,(x y),x D.1 y'
> doesn't seem to work for me either, and I really would prefer monadic,
> kinda seeing how "currying" maps to J.
>
>
>
>
>
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
