From J Wiki
Jump to: navigation, search

>> <<   Back to: Vocabulary Thru to: Dictionary

[x] u^:n y Fixed Power Conjunction

Rank Infinity -- operates on [x and] y as a whole -- WHY IS THIS IMPORTANT?

Note: x u^:n y is equivalent to (x&u)^:n y and will be discussed with the latter construct.

Applies verb u (or x&u, if dyadic) to y, n times. This may be interpreted as If or Inverse depending on n.

Common Uses

1. Conditionally execute a verb (eg. to save writing an if.-statement):

   flag=: 1
   'Mr. ' ,^:flag 'Jones'
Mr. Jones
   flag=: 0
   'Mr. ' ,^:flag 'Jones'

2. Execute the obverse (which is usually the inverse) of a verb:

   +: 14          NB. "Double"
   (+: ^:_1) 14    NB. the obverse of "Double" is "Halve"

See u^:v for the Do-While construct.

More Information

u^:Boolean If

If n is 0 or 1, it has a simple interpretation: if n=1, u is applied to y, while if n=0, y is left unchanged. I.e.  ^:n can be interpreted as If n.

   NB. Get the number of days in the current month; add 1 if February in leapyear.  *. = AND
   leapyear =: 1
   month =: 2
   ]dayinmonth =: >:^:(leapyear *. month = 2) month { 0 31 28 31 30 31 30 31 31 30 31 30 31
   month =: 3
   ]dayinmonth =: >:^:(leapyear *. month = 2) month { 0 31 28 31 30 31 30 31 31 30 31 30 31

The advantage of u^:n over if.-do.-end. is that u^:n is a phrase rather than a sentence, and can thus be made part of a longer phrase or a sentence without requiring multiple sentences.

u^:_1 (Inverse, aka Obverse)

If n is _1, it means "undo the effect of applying u." In J, this means to apply the obverse, which is the inverse of the verb unless an obverse has been explicitly assigned using u :.v.

   >: 5   NB. >: means add one
   >:^:_1 (6)   NB. The inverse means subtract one

u^:_ (Converge)

u^:_ means "apply u until the result stops changing".

   +/ i. 4 5  NB. +/ = 'add items together'.  Add rows to produce a list
30 34 38 42 46
   +/ +/ i. 4 5   NB. Doing it twice results in an atom
   +/^:_ i. 4 5   NB. 'keep totaling until you get an atom'
   +/^:_ i. 4 5 6  NB. works for any rank

Usually u^:_ is combined with u^:v, as described below.

Other Values of n

Other values of n are rarely used.

• Example: Parsing HTML
Given: Table Structure and Content.

mytable=: 0 : 0
<table ...>
 <tr ...>-1----------row1----------------1-</tr>
 <tr ...>-2----------row2-----------------------------2-</tr>
 <tr ...>-3----------row3---------------------3-</tr>
   dataypte mytable

Task: Parse the table and pick content of Row2.
Hint: Script strings.ijs (providing dyadic verbs taketo and takeafter) is part of the J standard library.

   y=. mytable;

   '<tr' takeafter y                                           NB. aiming at start of 1st row
 <tr ...>-2----------row2-----------------------------2-</tr>
 <tr ...>-3----------row3---------------------3-</tr>

   '<tr' takeafter(^:2) y                                      NB. after two cuts, near Row2
 <tr ...>-3----------row3---------------------3-</tr>

   '>' takeafter '<tr' takeafter(^:2) y                        NB. cut (including) closing bracket
 <tr ...>------------row3---------------------3-</tr>

   '</tr' taketo '>' takeafter '<tr' takeafter(^:2) y          NB. Row2's content, as requested


Array n

1. When n is an array, u^:a is executed for each atom a in n, and the results are then collected into an array whose frame is the shape of n

   *:^:(0 1 2 3) 5  NB. 5, 5^2, (5^2)^2, ((5^2)^2)^2
5 25 625 390625

2. n may not be empty.

Boxed Numeric n -- decoding variable-length records

The main use for boxed n is separating variable-length records.

When n is boxed, the contents of n must be an atom or empty. The results from executing u on y repeatedly are collected into a list of results.

If >n is finite, u^:n executes u ((>n)-1) times, collecting the results from each execution (if >n is negative, u^:_1 is executed ((->n)-1) times). The original value of y is collected as the first item of the result. Thus

   *:^:(<4) 5   NB. same as *:^:0 1 2 3
5 25 625 390625

If >n is _ or empty, u is repeatedly executed until the result stops changing. All the results are collected into an array. Since a: is <0$0, it is used for y in this case

   (0 >. <:)^:a: 5   NB. Decrement, but not below 0
5 4 3 2 1 0

Gerund n

When n is a gerund, it specifies preprocessing for the arguments, as well as a verb for calculating the value of n to use. After these steps have been performed, u^:n is applied as usual.

Gerund n is necessary only in tacit code. Inside the body of an explicit verb you could just write out the equivalent for the gerund.

The gerund form is

x u^:(v0`v1`v2)y <==> (x v0 y)u^:(x v1 y) (x v2 y)

The three verbs are applied to the arguments, producing the values to be used for x, n, and y respectively.

   'Mr.' ,^:((<@[)`(1 = #@])`]) <'Jones'  NB. Prepend boxed x if y has 1 atom
   'Mr.' ,^:((<@[)`(1 = #@])`]) 'Harry';'Jones'

If v0 is omitted, it is assumed to be ([) i.e. x is used unchanged.

If the use of u^:gerund is monadic, v0 must be omitted (since there is no x), and v1 and v2 are invoked monadically.

u^:(v`]) is the same as u^:v.

[x] u^:v y Dynamic Power Conjunction

Rank Infinity -- operates on [x and] y as a whole -- WHY IS THIS IMPORTANT?

Note: x u^:v y is equivalent to (x&u)^:(x v y) y and will be discussed with the latter construct.

If x is present

  • (x u^:v y) applies verb x&u to y n times, where n is the result of (x v y)
  • The number of times n that u is executed therefore depends on the values of the arguments x and y .

If x is absent

  • (u^:v y) applies verb u to y n times, where n is the result of (v y)
  • The number of times n that u is executed therefore depends on the value of the single argument y .

This yields the data-dependent constructs

Common Uses

1. Modify y based on the value(s) of [x] and y (see: Dynamic If)

   '.' (~: {:) 'Mr'  NB. Returns 1 if y does not end with x (.)
   '.' ,~ 'Mr'  NB. append x to the end of y
   '.' ,~^:(~: {:) 'Mr'  NB. append IF y does not end with x
   '.' ,~^:(~: {:) 'Mrs.'
   '.' ,~^:(~: {:)&.> 'Mr';'Mrs.';'Jack';'Sprat'   NB. Test & modify inside each box separately

2. Execute a verb repeatedly, until a condition is reached (see: Do-While)

   _2&(+/\) 3 1 4 1 5 9 2 6  NB. This verb adds adjacent items:  3+1, 4+1, 5+9, 2+6
4 5 14 8
   _2&(+/\) 45 30 5 7 22 12 40 55  NB. Applied once
75 12 34 95
   _2&(+/\)^:2 (45 30 5 7 22 12 40 55)   NB. Applied twice
87 129
   _2&(+/\)^:(100 > >./)^:_ (45 30 5 7 22 12 40 55)   NB. applied while max of y < 100
87 129
   _2&(+/\)^:(50 > >./)^:_ (45 30 5 7 22 12 40 55)  NB. applied while max of y < 50
45 30 5 7 22 12 40 55

Related Primitives

Agenda ([x] u@.v y)

More Information

Dynamic If

This is the construct: (u^:v y) or: (x u^:v y)

  • Verb v must always produce a Boolean result.
  • Verb u is applied if-and-only-if v returns 1.

The advantage of u^:v over if.-do.-end. is that u^:v can be executed on cells of an array rather than the array as a whole.

Execution on cells will happen if you combine u^:v with rank ("n) or use a member of the @ family (@, &, &., each, every).

If you need Dynamic If on the array as a whole, just use the u^:n form.

The control word if. (which tests a single condition) can't provide cell-by-cell control.

   +: 5                    NB. means: double
   +:^:(6&<) 12            NB. means: double IF y>6
   +:^:(6&<)"0 (0 3 6 12)  NB. means: double only atoms that are > 6
0 3 6 24

In the dyadic case, both u and v are invoked dyadically

   3!:0 'Smith'   NB. 3!:0 tests the type of y.  2=literal
   3!:0 (5)   NB. 4=integer
   'Mr. ' ,^:(2 = 3!:0@]) 'Smith'   NB. Prepend 'Mr.' IF y is a string
Mr. Smith
   'Mr. ' ,^:(2 = 3!:0@]) 5   NB. Otherwise leave y unchanged

Note: 3!:0@] was necessary, because 'Mr. ' 3!:0 'Smith' would have been a domain error.

Dyadic execution means that x and y must agree, which is sometimes problematic

   'Mr. ' ,^:(2 = 3!:0@])&.> 'Smith';5;'Jones';10;'Williams';15
|length error
|   'Mr. '    ,^:(2=3!:0@])&.>'Smith';5;'Jones';10;'Williams';15

The problem is that x has 4 atoms but y has 6 atoms.

Workaround: Use: x&u^:v rather than: x u@:v. Then the verb as a whole is no longer dyadic.

Note: Because of the long left scope of modifiers, x&u^:v is the same as: (x&u)^:v

   'Mr. '&,^:(2 = 3!:0@])&.> 'Smith';5;'Jones';10;'Williams';15
|Mr. Smith|5|Mr. Jones|10|Mr. Williams|15|


This is the construct: (u^:v^:_ y) or: (x u^:v^:_ y)

Do-While can be executed independently on cells of the arguments if you combine it with Rank ("n) or use a member of the @ family (@, &, &., each, every).

Despite its name, Do-While is very rarely used in J. Almost all looping is done using the other modifiers.

   3&*^:(100 > ])^:_ (5)            NB. triple y while it is less than 100
   3&*^:(100 > ])^:_"0 (5 6 7 20)   NB. same, but test each atom independently
135 162 189 180

Use These Combinations

Combinations using u^:v that have exceptionally good performance include:

What it does Type;


Syntax Variants;



Bug Warnings

Find ordinal numbers of y (the relative rank of each item of y in the sort order /:@/: y note \: is not special better than /:^:2 y
Follow a chain of variable-length records integer x and y {&x^:a: y

x {~^:a: y

<_ in place of a: Produces list of starting positions. Limit all values of x to at most #x, then append _1 to the end of x. Discard the final starting position of _1.
Monadic power whose power depends on x x f@]^:g y

(f is any verb)

Applies f rather than x&(f@]) (very small improvement)

CategoryVoc CategoryVocLoop CategoryVocRecursion