0racle/jprofile.md

## jprofile.md

      
    Raw
  

              jprofile.md
            
          
    Here's a rundown of definitions in my .jprofile.ijs, which get loaded in all J sessions.
Some of these are so simple they don't need names, but sometimes I just put things in here so I don't forget how to spell them.
Not all the functions are the most efficient, they're just there for playing with data. Often in a script, I will copy a function in, or re-write one that is more specific to the given problem domain.
Names

Alphanumerics

NB. AlphaNumerics             || Golf versions
azuc   =: (65 ,: 26) ];.0 a.  NB. u: 65 + i. 26
azlc   =: (97 ,: 26) ];.0 a.  NB. u: 97 + i. 26
digits =: (48 ,: 10) ];.0 a.  NB. u: 48 + i. 10
alnum  =: azuc,azlc,digits
These are useful in light string parsing, and also as test data
Functions

Visualise boolean arrays different ways

B =: 0&$: : {{
    B0 =. ((u: 183 9619) { ~ ])"2
    B1 =. (u: 16b20 16b2584 16b2580 16b2588) {~ (,:~2 1) #.@,;._3 ]
    B2 =. (,:~4 2) (10240 u:@+ 40283 #.@A. ,);._3 ]
    B3 =. ((u: 11036 11035) { ~ ])"2
    B0`B1`B2`B3@.x y
}}
I originally had just B defined like B0, but I then I nabbed the others from here.
Example usage
   B (<:/&i. -) 5
▓▓▓▓▓
▓▓▓▓·
▓▓▓··
▓▓···
▓····
   1 B (<:/&i. -) 10
█████████▀
███████▀
█████▀
███▀
█▀
   2 B (<:/&i. -) 20
⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋
⣿⣿⣿⣿⣿⣿⡿⠋⠀⠀
⣿⣿⣿⣿⡿⠋⠀⠀⠀⠀
⣿⣿⡿⠋⠀⠀⠀⠀⠀⠀
⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀
Box and laminate arrays for comparison

Over =: (8!:1)@,:&(<"_1)

On =: {{
    x ((,:&(<"_1))`((,~ <"_1)~)@.(32 = (3!:0) {. y)) y
}}
Over is a convenience function for comparing 2 arrays that may be of different types (hence the boxing).
Similar to the ,[0.5] thingy in APL.
   (Over azlc&i.) 'alphabetical'
┌─┬──┬──┬─┬─┬─┬─┬──┬─┬─┬─┬──┐
│a│l │p │h│a│b│e│t │i│c│a│l │
│0│11│15│7│0│1│4│19│8│2│0│11│
└─┴──┴──┴─┴─┴─┴─┴──┴─┴─┴─┴──┘
   (Over B@e.&'aeiou') 'iversonian'
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│i│v│e│r│s│o│n│i│a│n│
│▓│·│▓│·│·│▓│·│▓│▓│·│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
On is a more heavy-weight version that doesn't format the output, and can stack multiple lists
   (i. 4) On 'RULD' On (, -) =/~ i. 2
┌───┬───┬────┬────┐
│0  │1  │2   │3   │
├───┼───┼────┼────┤
│R  │U  │L   │D   │
├───┼───┼────┼────┤
│1 0│0 1│_1 0│0 _1│
└───┴───┴────┴────┘
I use Over more, so I should probably swap the names around 🤷
Extract natural numbers from string

Nats =: {{ ". ('1234567890 ') {~ '1234567890' i. y }}
Pretty self explanatory
   */ Nats '175m × 50m'
8750
Partition adverb similar to APL's ⊆

P =: {{ (1, 2 </\ x) u;.1&((0 < x)&#) y }}
This closely mimics the APL operator, and - among other uses - can also be used to extract numbers from a string.
   digits (e.~ <P ]) '175m × 50m'
┌───┬──┐
│175│50│
└───┴──┘
   */ digits (e.~ ".P ]) '175m × 50m'
8750
See this gist for more examples.
Extract runs from a sequence

Runs =: {{ y u;.1~ 1, 2 ~:/\ v y }}
Conjunction for processing "runs" of values.

v defines how to identify runs,
u defines what to do with those runs

   <Runs] 'aabcccaaaaabbbc'
┌──┬─┬───┬─────┬───┬─┐
│aa│b│ccc│aaaaa│bbb│c│
└──┴─┴───┴─────┴───┴─┘
   #Runs] 'aabcccaaaaabbbc'
2 1 3 5 3 1
   <Runs('a'=]) 'aabcccaaaaabbbc'
┌──┬────┬─────┬────┐
│aa│bccc│aaaaa│bbbc│
└──┴────┴─────┴────┘
If you don't care about false runs, use P
   (('a'=]) <P ]) 'aabcccaaaaabbbc'
┌──┬─────┐
│aa│aaaaa│
└──┴─────┘
Modify values in an array with a function

Adjust =: (@{)`[`]}    NB. {{ (u x { y) x} y }}

Alter =: {{ x } y ,: u y }}
Adjust is Like Amend } but takes a function to modify selected items
   2 3 (*&10) Adjust i.  6
0 1 20 30 4 5
   ] a =. 1 (< ;~ i. 3)} 5 5 $ 0
1 1 1 0 0
1 1 1 0 0
1 1 1 0 0
0 0 0 0 0
0 0 0 0 0
   (<1 2 3;1 2 3) (1 XOR ]) Adjust a
1 1 1 0 0
1 0 0 1 0
1 0 0 1 0
0 1 1 1 0
0 0 0 0 0
Alter is a similar function which takes a mask instead of indices
This is kinda like BQN's "Under Select" {𝔽⌾(𝕨⊸/)𝕩}
   0 1 1 0 0 toupper Alter 'alter'
aLTer
   (];.0 a) (1 XOR ]) Alter a
1 1 1 0 0
1 1 1 0 0
1 1 0 1 1
0 0 1 1 1
0 0 1 1 1
A minor concern you might have is that Alter performs u to the whole of y, which may be wasteful.
Use can modify the fork ($ #: I.@,) (which converts a boolean matrix to indices) to use a mask with Adjust
   (($ <@#: I.@,) (];.0 a)) (1 XOR ]) Adjust a
1 1 1 0 0
1 1 1 0 0
1 1 0 1 1
0 0 1 1 1
0 0 1 1 1
Amend. Adjust. Alter. Yes, I used a thesaurus.
Insert values (splice)

Insert =: {{ m ({. , x , }.) y }}
Inserts x in y, at position m
   'Three' 6 Insert 'OneTwoFour'
OneTwoThreeFour
Shuffle array

Shuffle =: $ $ ({~ ?~@#)@,
Randomises position of all items in a matrix across ranks.
Use it with Rank " to limit it's effect
   <"_1 Shuffle i. 2 2 3
┌───────┬─────┐
│5 10 11│7 8 1│
│0  4  9│6 3 2│
└───────┴─────┘
   <"_1 Shuffle"1 i. 2 2 3
┌─────┬───────┐
│1 0 2│ 6 7  8│
│3 5 4│11 9 10│
└─────┴───────┘
   <"_1 Shuffle"_1 i. 2 2 3
┌─────┬───────┐
│3 5 4│11 8  9│
│1 0 2│ 6 7 10│
└─────┴───────┘
Indices inverse

Iinv =: e.~ i.@>:@{:
Simple Indices inverse (only works with sorted lists)
   ] p =. /:~ 10 ? 20
1 5 6 7 8 9 10 11 15 17
   Iinv p
0 1 0 0 0 1 1 1 1 1 1 1 0 0 0 1 0 1
   I. Iinv p
1 5 6 7 8 9 10 11 15 17
Still waiting for (I.^:_1). See: jsoftware/jsource#51
Consecutive integers from x to y (inclusive)

To =: ([ + i.@(>:@-~))`(|.@$:~)@.>
Return a [closed, closed] range from x to y, either ascending or descending.
   _3 To 11
_3 _2 _1 0 1 2 3 4 5 6 7 8 9 10 11
   11 To _3
11 10 9 8 7 6 5 4 3 2 1 0 _1 _2 _3
If I want [closed, open), I can always just }:
Three-way comparison

Cmp =: {.@(/: - \:)@,&<
Get single "order" - like < or > - but on Array
   1 2 3 Cmp 1 3 2
_1
   'alpha' Cmp 'beta'
_1
   'gamma' Cmp 'beta'
1
Odometer monad

Odm =: #: i.@(*/)
Like K's !
   |: Odm 3 3
0 0 0 1 1 1 2 2 2
0 1 2 0 1 2 0 1 2
Iota monad

Iota =: #: i.
Like APL's ⍳ or BQN's ↕, given multiple values
   <"1 Iota 3 3
┌───┬───┬───┐
│0 0│0 1│0 2│
├───┼───┼───┤
│1 0│1 1│1 2│
├───┼───┼───┤
│2 0│2 1│2 2│
└───┴───┴───┘
Aliases

Some shorter (possibly inverse-able) versions of existing functions.
Ord =: (u:^:_1) :. (u:)
Chr =: (u:) :. (u:^:_1)

Uc  =: toupper :. tolower
Lc  =: tolower :. toupper

NB. Left-shift and Right-shift
Ls  =: (1&$:) : (|.!.'')
Rs  =: Ls&.|.
Time & Space

ts =: {{
    echo < dtbs,/ 'timespacex × ',('c' (8!:2) x)
    result =. x&{{ y ; (8!:0) (x, 1) * x timespacex y }}@> cutopen y
    echo ,. ('expr';'time';'space') , result
}}
A subjectively prettier timespacex
   1e6 ts '> , { ;~ i: 1';',/ ,"0/~ i: 1'
┌──────────────────────┐
│timespacex × 1,000,000│
└──────────────────────┘
┌─────────────┬────────┬─────┐
│expr         │time    │space│
├─────────────┼────────┼─────┤
│> , { ;~ i: 1│1.834701│3520 │
├─────────────┼────────┼─────┤
│,/ ,"0/~ i: 1│1.389705│2880 │
└─────────────┴────────┴─────┘
File / Path stuff

curfile =: {{ _1 {:: (4!:3) $ 0 }}
curpath =: ] ,~ 0 {:: fpathname@curfile
chdir   =: (1!:44)
The cur* verbs are probably not 100% reliable but works for my use case. Probably named poorly, because it's not cwd. Maybe should be scriptpath, but whatever.