In this short post, I express the Scmutils notation for partial derivatives of scalar functions with multiple parameters using JavaScript. As usual, you find the JavaScript program by following the Source Academy link, but this time, you need to change the language from Source §4 to “full JavaScript”.

## The Single-parameter Case

An example of a scalar function with one parameter is the `square` function.

``````const square = x => x * x;
``````

A naive numerical differentiation function follows the definition of derivatives, using Lagrange’s notation: `f'(x) = (f(x + d) - f(x)) / d`, where `d` approaches 0. Translating this definition to JavaScript yields differentiation function.

``````const differentiate = f => x => (f(x + delta) - f(x)) / delta;
``````

I call it “naive” because rounding errors creep in very quickly, if `delta` is chosen to be very small. For precise methods of numerical differentiation, see an earlier post. To explore the notation for differentiation, I ignore these issues and stick to the naive version with a relatively large `delta`.

``````const delta = 1e-4;
``````

Using this `differentiate` function, you can differentiate `square` as follows.

``````differentiate(square);    // returns a function square'
// approximately square'(x) = 2 * x
``````

Applying the function that results from differentiating `square` to 1 gives approximately 2.

``````differentiate(square)(1);
``````

The square function above only has one argument, so when you write `square'`, it is clear what argument you are differentiating for.

## Multiple Parameters

The problem with Lagrange’s notation is that it doesn’t spell out which parameter(s) you are differentiating for when there are multiple parameters.

For functions with multiple parameters, you would like to compute a partial derivative by changing one value and leave the other values unchanged.

For example, you would like to compute the partial derivative of `f(x, y) = x² + x y + y²` separately with respect to `x`, and with respect to `y`.

Euler’s notation uses the parameter name for this, regardless of its position in the list of arguments: `(Dx f)(x, y) = (f(x + d, y) - f(x, y)) / d` where `d` approaches 0

and `(Dy f)(x, y) = (f(x, y + d) - f(x, y)) / d` where `d` approaches 0

In the use cases of Scmutils, functions are often generated by other functions, and then the parameter names may not be obvious.

## Scmutils Notation for Partial Derivatives

Scmutils solves the issue by defining a function `partial` that takes a subset of the parameter indices (rather than names) of the function to be differentiated, and returns a function transformer: A function that differentiates its argument function with repect to the parameters indicated by the indices.

Let’s start with the naive partial derivative with respect to a single parameter index:

``````const partial_single =
i => f => (...x) => (f(...add_to_index(x, i, delta))
- f(...x))
/ delta;
``````

where the helper function `add_to_index` adds a value `delta` to the `i`th component of the vector `values`.

``````const add_to_index =
(values, i, delta) => values.map((x, j) => i === j ? x + delta : x);
``````

You can apply `partial_single` to 0 and `f` and get the partial derivative of `f` with respect to the first parameter `x`

``````partial_single(0)(f);         // returns Dx f
partial_single(0)(f)(1, 2);   // returns Dx f(1, 2), approximately 4
``````

or with respect to parameter `y`

``````partial_single(1)(f);         // returns Dy f
partial_single(1)(f)(1, 2);   // returns Dy f(1, 2), approximately 5
``````

You can use `partial_single` to differentiate the square function.

``````partial_single(0)(square);    // returns approximately Dx square: square'(x) = 2 * x
partial_single(0)(square)(1); // returns approximately square'(1) = 2
``````

The `partial` function in Scmutils takes multiple parameter indices as arguments and returns a function transformer: A function that differentiates a given scalar function with repect to each of the indices. The corresponding JavaScript function `partial` is defined as follows, using a given `partial_single` function.

``````const partial =
(...ids) => ids.length === 0
? f => f // base case: no index given: keep f as it is
// ids.slice(1) removes the first index from ids
: f => partial_single(ids[0])(partial(...ids.slice(1))(f));
``````

To illustrate `partial`, let’s define `g(x, y, z) = x² + 2 y² + 3 z² + x y z`.

``````const g = (x, y, z) => square(x) + 2 * square(y) + 3 * square(z) + x * y * z;
``````

Now, you can play with `partial` and `g`:

``````partial(2)(g)(1, 2, 3);   // returns Dz g(1, 2, 3), approximately 20
partial(0,1)(g)(1, 2, 3);   // returns Dx Dy g(1, 2, 3), approximately 3
partial(0,2)(g)(1, 2, 3);   // returns Dx Dz g(1, 2, 3), approximately 2
partial(0,1,2)(g)(1, 2, 3);   // returns Dx Dy Dz g(1, 2, 3), approximately 1
``````

## The Nabla Function

The Nabla function (usually denoted by the symbol ∇) is a function transformer that takes a multi-parameter scalar function `f` as argument and returns a multi-parameter function that returns the gradient vector of `f` at the given position. In JavaScript, the Nabla function can be defined using `partial_single` as follows:

``````const Nabla = f => {
// indices is vector [0, 1,...,n] where n is arity of f
const indices = Array(f.length).fill().map( (ignore, i) => i);
// partials is vector [Dx f, Dy f,...] if f has parameters x, y, ...
const partials = indices.map(i => partial_single(i)(f));
return (...x) => partials.map(p => p(...x));
};
``````

For example, you can apply `Nabla` to the function `f` above as follows.

``````Nabla(f);          // the Nabla function of f

Nabla(f)(1, 2);    // the gradient vector of f at position (1,2),
// approximatately [4, 5]
``````

For the function `g` you get:

``````Nabla(g)(1, 2, 3);    // the gradient vector of g at position (1,2,3):
// [Dx g(1,2,3), Dy g(1,2,3), Dz g(1,2,3)], approximately
// [8, 11, 20]
``````