Also, this has only forks:

 

5!:4 <'t1'

      ┌─ 2                  
  ┌───┼─ {.                 
  │   └─ [                  
  ├─ $                      
  │        ┌─ [:            
──┤   ┌────┼─ ;             
  │   │    └─ ]             
  │   ├─ /:                 
  └───┤    ┌─ [:            
      │    ├─ ;             
      └────┤    ┌─ [:       
           │    ├─ /. ─── < 
           └────┤           
                │      ┌─ [:
                └──────┼─ i.
                       └─ [ 

 

This has both forks and hooks:

 

   5!:4 <'t2'

      ┌─ 2              
  ┌───┼─ {.             
  │   └─ [              
  ├─ $                  
──┤   ┌─ ]              
  │   │     ┌─ /:       
  │   ├─ & ─┴─ ;        
  └───┤                 
      │     ┌─ [:       
      │     ├─ /. ─── < 
      └─────┤           
            │      ┌─ [:
            └──────┼─ i.
                   └─ [ 

   

Linda

 

-----Original Message-----
From: [email protected] [mailto:programming-
[email protected]] On Behalf Of Linda Alvord
Sent: Saturday, February 02, 2013 2:00 AM
To: [email protected]
Subject: Re: [Jprogramming] inverse oblique

 

I remember fondly how Ken loved to read the unabridged dictionary. Richness
of the language and the derivations of the words was a joyous experience
for him.  The J language has this same richness.

 

For students coming to the language with years of mathematical background
in abstract algebra, calculus, differential equations and the like, they
are ready t o jump easily to abstract combinations.

 

I keep thinking in terms of the long time it takes high school students to
master functional notation like  f(x)  and  g(x).

 

 

To get from  t1 to t2 requires and "idiom"  x u&v y ↔ (v x) u (v y)

 

t1=: 13 :'(2{.x)$(;y)/:;</.i.x'

t2=: 13 :'(2{.x)$y/:&;</.i.x'

 

So although t1 is longer than t2,  t2 is more condensed and compex.  This
is why I say easier:

 

    t1

(2 {. [) $ ([: ; ]) /: [: ; [: </. [: i. [

    t2

(2 {. [) $ ] /:&; [: </. [: i. [

 

The condensed spacing of  /:&;  gives away the increased complexity of the
second tacit version.

 

My guess is that you would spend less time reading the dictionary to master

t1 than t2.

 

Linda

 

-----Original Message----- wo

From:  <mailto:[email protected]> programming-
[email protected] [mailto:programming-
<mailto:[email protected]> [email protected]] On
Behalf Of Raul Miller

Sent: Friday, February 01, 2013 9:20 AM

To:  <mailto:[email protected]> [email protected]

Subject: Re: [Jprogramming] inverse oblique

 

How do you define "easier"?

 

In my opinion, it's easier to go from simple (fewer tokens) to complex
(more tokens), but also someone has to write the code to do the
transformation and until that's been done even this concept of "easier" can
be indistinguishable from "can't be done".

 

--

Raul

 

On Fri, Feb 1, 2013 at 5:05 AM, Linda Alvord <
<mailto:[email protected]> [email protected]>

wrote:

>  If t1 is easy tacit and t2 is advanced tacit, wouldn't it be easier 

> for  J to figure  t2  from  t1  than it is for me?

> 

>     t=: 5 7 2 ?@$ 1e6

>     s=: $t

>     x=: </.t

>    t1=: 13 :'(2{.x)$(;y)/:;</.i.x'

>    t-:s f x

> 1

>    t2=: 13 :'(2{.x)$y/:&;</.i.x'

>    t-:s g x

> 1

>    t1

> (2 {. [) $ ([: ; ]) /: [: ; [: </. [: i. [

>    t2

> (2 {. [) $ ] /:&; [: </. [: i. [

> 

> Or is that just wishful thinking?

> 

> Linda

> 

> 

> -----Original Message-----

> From:  <mailto:[email protected]> programming-
[email protected]

> [ <mailto:[email protected]> mailto:programming-
[email protected]] On Behalf Of Roger 

> Hui

> Sent: Thursday, January 31, 2013 1:49 PM

>  To: Programming forum

> Subject: Re: [Jprogramming] inverse oblique

> 

>    t -: (2{.s) $ x /:&; </.i.s

> 1

> 

> 

> 

> On Thu, Jan 31, 2013 at 10:47 AM, Roger Hui

> < <mailto:[email protected]> [email protected]>wrote:

> 

>>    t=: 5 7 2 ?@$ 1e6

>>    s=: $t

>>    x=: </.t

>> 

>>    t -: (2{.s) $ (;x)/:;</.i.s

>> 1

>> 

>> 

>> 

>> On Thu, Jan 31, 2013 at 10:28 AM, Raul Miller

> < <mailto:[email protected]> [email protected]>wrote:

>> 

>>> Let's start with an arbitrary array:

>>> 

>>>    A=: i. 2 3

>>> 

>>> We can box oblique lines from this array:

>>> 

>>>    </. A

>>> +-+---+---+-+

>>> |0|1 3|2 4|5|

>>> +-+---+---+-+

>>> 

>>> However, the interpreter does not currently provide us with an 

>>> inverse for this operation:

>>> 

>>>    </.inv </. A

>>> |domain error

>>> 

>>> One problem is that you cannot uniquely determine the first two 

>>> elements of the shape of the original array by inspecting </.'s

>>> result:

>>> 

>>>    (</. 5 7$0) -: </.7 5$0

>>> 1

>>> 

>>> If its shape is provided, how might we reconstruct the original array?

>>> 

>>> [For the sake of simple code, it's ok to focus on numeric, rank 2 

>>> arrays.]

>>> 

>>> --

>>> Raul

>>> --------------------------------------------------------------------

>>> -

>>> - For information about J forums see 

>>>  <http://www.jsoftware.com/forums.htm>
http://www.jsoftware.com/forums.htm

>>> 

>> 

>> 

> ----------------------------------------------------------------------

> For information about J forums see  <http://www.jsoftware.com/forums.htm>
http://www.jsoftware.com/forums.htm

> 

> ----------------------------------------------------------------------

> For information about J forums see  <http://www.jsoftware.com/forums.htm>
http://www.jsoftware.com/forums.htm

----------------------------------------------------------------------

For information about J forums see  <http://www.jsoftware.com/forums.htm>
http://www.jsoftware.com/forums.htm

 

----------------------------------------------------------------------

For information about J forums see  <http://www.jsoftware.com/forums.htm>
http://www.jsoftware.com/forums.htm

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

Reply via email to