Conditional structures/J
if-then
if. is a simple conditional structure in J. As other control words, if.
can be used only within definitions of other syntactic elements.
<lang j> test=: monad define if. 5 > 4 do. 123 end. )
test
123
test=: monad define
if. y > 4 do. y * 2 elseif. y = 4 do. 'exactly' elseif. do. y - 10 end. )
test 5
10
test 4
exactly
test 3
_7</lang> The condition may be omitted, or it may be empty (like an array with 0 elements). In this cases the condition is considered to be satisfied.
select-case
select. is another conditional structure. case.
match causes the execution of this case.
branch and then terminates the further structure execution. fcase.
match after the execution of the associated code executes the next branch; if that's with fcase.
again, it again executes the next branch, etc.
<lang j> test=: monad define t1=. 'Count to three? ' select. y fcase. 1 do. t1=. t1 , 'one ' fcase. 2 do. t1=. t1 , 'two ' case. 3 do. t1=. t1 , 'three' case. 4 do. 'Just four' end. )
test 2
Count to three? two three
test 1
Count to three? one two three
test 4
Just four
test 5
Count to three?</lang>
power
Another way to execute code conditionally is power conjunction. In the code u ^: v y
verb u
is executed with argument y
only if v y
condition is satisfied.
<lang j> ('magic number'&[) ^: (=&42) 5 5
('magic number'&[) ^: (=&42) 6
6
('magic number'&[) ^: (=&42) 42
magic number</lang>
agenda
Another way to execute code conditionally is the agenda conjunction. In the code u0`u1`...`uN @. v y
result of v y is an index in the range 0..N which determines which of the functions u0..uN will be executed. (Also negative numbers greater than -N are treated as N-(v y).)
<lang j> (2&+)`(3&+)`(5&+) @. * 2 5
(2&+)`(3&+)`(5&+) @. * _2
3</lang>
Here, * without a left argument is signum (1 for positive numbers and _1 for negative numbers).
conditions without conditions
Conditional effects can often be obtained without conditional structures. In J, a boolean result is a 1 or a 0, where 1 represents true and 0 represents false. If we have a boolean array B
which corresponds in shape to a numeric argument Y
, and we have a function F
where we want the result of F Y
where B
is true, and instead want the original value of Y
where B is false, we can use an expression like:
<lang J>(Y * -. B) + B * F Y</lang>
This also assumes, of course, that F is well behaved (that we can ignore any issues related to side effects), and has the right shape. [The token -.
is J's boolean "not" verb. And the tokens +
and *
are J's addition and multiplication verbs.]
If you do not want to pay for the execution of F Y
for cases where B
is false, and if Y
is a simple list, then a variation would be:
<lang J>(Y * -. B) + F&.(B&#) Y</lang>
For example:
<lang J> Y=: p: i. 5
Y
2 3 5 7 11
B =: 1 0 1 0 1 F=: *: (Y * -. B) + B * F Y NB. square some but not all primes
4 3 25 7 121
F B # Y
4 25 121
(Y * -. B) + F&.(B&#) Y
4 3 25 7 121</lang>