from Avi Gross ,  a fellow very long term investor in a ` smart glass company " in development " about as long as CoSy ,  triggered my following the link he mentioned , eventually to Conor Hoekstra's  APL vs BQN vs J vs Q vs NumPy vs Julia vs R prompting the email below which ended up not getting sent until now  :

---

Conor ,

While 4th.CoSy is still only my creation , the product of an adult life in APL , evolved and simplified thru K , as an open vocabulary in Forth , it is at the same level of expressive power as the languages you demonstrate but far simpler being Forth RPN -- and radically more flexible being open code all the way to the ` silicon . Chuck Moore's simple use of whitespace as the prime delimiter is an unappreciated brilliance .

  Here's a rather complete answer to Avi's question which in r-bloggers  is :

    Find the GCD (greatest common divisor) of the smallest and largest numbers in an array

and the solution given in Dyalog APL is

    ⌈/∨⌊/

I believe ` or , ∨ , was extended to also be gcd after I split with traditional APL following Arthur Whitney into K because of its greater simplicity and transparency of structure . Thus CoSy is purely lists of lists . In fact , at the Forth ( hardware ) level the 3 cell header of a CoSy object is simply `( Type Count refCount )` . Thus it intrinsically follows your " Leading Axis " notion .

I wasn't sure whether I had implemented gcd in 4th.CoSy so I checked old K.CoSy . This is the definition I used there :

gcd
 Greatest Common Divisor . From Eugene McDonnell's Kidioms list
{ * | 1 + & &/' 0 = x !/: 1 + ! &/ x }

It works on whole lists . When I examine it , it's not terribly efficient .

I see that I do have a gcd in the current https://cosy.com/4thCoSy/Code/CoSy/math.f script :

: _gcd ( a b -- c) | Jack Browns recursive  greatest common divisor | raw Forth
    dup if swap over mod _gcd else drop then ;
 | From https://ronware.org/reva/wiki/index.php/Intermediate_Tutorial
 
: gcd ' >_ on2 _gcd _i ;     | ' gcd at CoSy level

Brown's algorithm looks pretty efficient . I don't think the recursion could ever go very deep . Here are the definitions and  the x86 for mod and /mod which get called .

       `( mod /mod )` { dup Help $ See ,L } 'm
    (
     (
      mod ( a b -- n ) 'forth
    Context: ~
    Source in: src/reva.f
        Divide a by b, and put the modulus (remainder) on TOS: n=a%b
    See also: * */ + - / /mod 1+ 1- 2* 2/ << >>

    0061BEE8  E8 E3 FF FF FF              call /mod
    0061BEED  8B 06                       mov eax,[esi]
    0061BEEF  8D 76 04                    lea esi,[esi+04]
    0061BEF2  C3                          ret

     ) (
      /mod ( a b -- rem quo ) 'forth
    Context: ~
    Source in: src/reva.f
        Divide "a" by "b", place remainder and quotient on stack
    See also: * */ + - / 1+ 1- 2* 2/ << >> mod

    0061BED0  89 C3                       mov ebx,eax
    0061BED2  8B 06                       mov eax,[esi]
    0061BED4  99                          cdq
    0061BED5  F7 FB                       idiv ebx
    0061BED7  89 16                       mov [esi],edx
    0061BED9  C3                          ret
     ) )

One of CoSy's brilliances is that all indexing is modulo . This subsumes such notions as scalar extension and eliminates all length errors .

Another brilliance of Forth is that the single quote , ' , returns the address of the next word , even if its a verb . Thus defining verbs which take both nouns and verbs as arguments ( I like Iverson & Hui's use of adverb for such words ) is trivial . For instance , the phrase in ' gcd above

' >_ on2

  applies  >_

: >_ ( disclose  non-nested  and free if 0 refs ) dup 0 i@ swap ref0del ;

to each of the top 2 CoSy level stack items to get the raw numbers the Forth level _gcd needs .

Anyway , here's an answer to the original problem

  i( 18 24 32 0 )i >t0
  t0  .+   ' maxi ./ $  ' mini ./  gcd    
| dup the list , apply ' max across ,
|  swap ( aka commute ) , apply ` min across , then ' gcd between them
32
: minmaxgcd .+   ' maxi ./ $  ' mini ./  gcd ;    | make it a word

  t0 -1 _cut  minmaxgcd            | drop that trailing 0 . Do again .
2

Conor , I think you can see that CoSy , immature and in need of more heads as it is , is on a level comparable to those other array languages , but far simpler -- and being simply a vocabulary in open Forth , is unmatched in flexibility . CoSy as it stands is just a starting point -- a bridge between brilliances of Iverson and Moore .

All the best ,

Bob A

---

Full https://cosy.com/y23/Blog60days.html