Don Guinn wrote:
> Wouldn't sliding the right argument over the left and leaving a result there
> imply that the left argument is replaced with the result?
Skip replies:

I did not mean to imply that the final result sum would remain on the 
left side of the plus. The left and right arrays don't move at all in 
the animation. The two original arrays should never move or change 
throughout the whole process. This shows that the original variables 
were not altered or destroyed.

I intended that a "ghost image" of the right array would move to the 
left and slide over the left array, implying the "lining up" of the left 
and right array values. Only the ghost image of the right array moves to 
line up with the left array. The right array stays where it began. Ghost 
implies "transparent". This "lining up" is a key concept in J and needs 
to be clearly shown.

Once the right ghost array is moved and aligned with the left array, the 
values of the ghost array should change to the sum result array, and the 
transparent ghost sum array should become "real" (non-transparent, or 
solid). This is the visual action that indicates the addition has been 
performed.

Only the ghost array values gets changed from the left array values to 
the summed values when it is moved over the right array and becomes 
solid. The underlying right array doesn't change at all.

Once the ghost sum array had been solidified, it should be moved down 
below the two original arrays. The two original arrays will be left as 
they were when the process started.

The variable-width font messed up the display I was trying to show. 
Hopefully, this second cut ill look better.

so you start with   2 + 3

and you end:        2 + 3

                      5    NB. The 5 is the ghost array that started 
                               on the right, moved to the left, changed 
                               to the sum and solidified, and then 
                               moved below the original two numbers.
------------------------------------------------------------------------

you start      1 + 2 3 4
 
                               NB. In this example it might be good to 
                                   use a middle step to show how the 
                                   left arg is replicated:

middle step   1 1 1 + 2 3 4    NB. The replicated ones could be "ghosted"
                                   to indicate their temporary status.

you end       1 + 2 3 4        NB. The replicated ones disappear as the 
                                   answer array is solidified and moved
                3 4 5              under the original equation
                         
------------------------------------------------------------------------

you start       1 2 3 + 4 5 6

you end:        1 2 3 + 4 5 6

                   5 7 9
------------------------------------------------------------------------

you start        1 2 3   1 2 3
                 4 5 6 + 4 5 6
                 7 8 9   7 8 9

you end          1 2 3   1 2 3
                 4 5 6 + 4 5 6
                 7 8 9   7 8 9
                      
                    2  4  6
                    8 10 12
                    4 16 18


Skip Cave
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to