Let’s talk about Ωe^{Ω} = 1. Here’s a great blackpenredpen video about calculating this value:

This got me thinking about J, because it has some interesting “adverbs” for doing these sorts of calculations. For starters, there is a built-in numerical derivative operator D., and the power adverb, which has a note that giving an infinite power computes the limit. I think of it as a fixed-point operator: it repeatedly feeds the output back in as an input until the input and output are equal, which is a fixed point. The power adverb turns out to be a hugely useful control construct in several ways—you can use it to describe various kinds of conditions as well as loops.

The first problem in J is figuring out how to express the function Ωe^{Ω} - 1 = 0. A little help from `13 :`

produced this: `1 -~ ] * ^`

. As usual, you read J from right to left. Start with the fork `] * ^`

. `]`

is effectively `id`

for functional programmers. `^`

is exponentiation; the dyadic form, such as `2^3`

calculates 2^{3}, for instance, and the monadic form `^x`

computes e^{x}. The fork trick being that the result of applying the left and the right are fed in as the left and right arguments to the center verb, `] * ^`

is exactly xe^{x}. `1 -~`

exploits a little trick about J, that constants can occur in certain positions of a fork or hook and act as values instead of functions, and because `~`

flips the arguments of a verb, `1 -~ ...`

at the start of a train is a great way to signify “… - 1” in a formula. xe^{x} = `1 -~ ] * ^`

.

There turns out to be no need to determine the derivative, because we can use the `D.`

adverb. In fact, there is an essay about Newton’s method on the J software site; I wound up having to change `d.`

to `D.`

for reasons I don’t understand. In the end, we wind up with this adverb definition: `N =. 1 : '- u % u D. 1'`

. Applying this once looks like:

```
(1 -~ ] * ^) N ] 1
0.68394
```

Applying it two more times looks like:

```
(1 -~ ] * ^) N ] 0.68394
0.577455
(1 -~ ] * ^) N ] 0.57745
0.56723
```

But, we can just let the power adverb iterate it for us until we converge:

```
(1 -~ ] * ^) N^:_ ] 1
0.567143
```

Not enough precision? We can always ask for more:

```
0j50 ": (1 -~ ] * ^) N^:_ ] 1
0.56714329040978384011140178699861280620098114013672
```

In the end the whole program is these two lines:

```
N =. 1 : '- u % u D. 1
0j50 ": (1 -~ ] * ^) N^:_ ] 1
0.56714329040978384011140178699861280620098114013672
```

Unbelievable.

Curious how many iterations it took? If you give a boxed value to `^:`

, it will give you all the intermediates. So we can use `#`

to count them up and `<_`

to produce an infinity in a box and find out:

```
# 0j50 ": (1x -~ ] * ^) N^:(<_) ] 1x
317
```

For six places, it only takes 6 tries:

```
# (1x -~ ] * ^) N^:(<_) ] 1x
6
(1x -~ ] * ^) N^:(<_) ] 1x
1 0.68394 0.577454 0.56723 0.567143 0.567143
```

#### Update on `D.`

and `d.`

There are a few differences between `D.`

and `d.`

in modern J. The version of Newton’s method on the wiki page actually does work for this definition of Ωe^{Ω} = 1: `<:@(] * ^)`

. There is not a huge difference between this and `1 -~ ] * ^`

, just that in the original case we are performing an argument-swapped subtraction with 1. In the new case we are composing a decrement function. The derivative operator `d.`

is able to symbolically differentiate this definition, probably by simply discarding increment and decrement in composition since such things would fall off in general according to the power rule:

```
<:@(] * ^) d. 1
^ + ] * ^
(] * ^) d. 1
^ + ] * ^
```

This is just the fact that d/dx(xe^{x} - 1) = d/dx(xe^{x}) = xe^{x} + e^{x}.

In short, the differences between `D.`

and `d.`

are:

`d.`

performs symbolic differentiation`D.`

performs numeric approximation of a derivative`D.`

has different rank`D.`

can be used to produce partial derivatives as well