A partly-novel arithmetic operator

I was recently surprised to notice an area where orthogonality and consistency suggest the existence of an arithmetic operator which (to my knowledge) no programming language offers.

Most programming languages spell multiplication as infix *, and division as infix /. So knowing that x * y == z means you also know that x / z == y (at least for rationals and infinite-precision reals).

Some programming languages (including Ada, Bash, COBOL, Fortran, Haskell, OCaml, Perl, Python, and Ruby, to name a few) spell exponentiation as infix **, such that 2 ** 10 == 1024. There’s a clear mathematical connection between ** for exponentiation and * for multiplication; just as multiplication can be viewed as repeated addition, so too can exponentiation be viewed as repeated multiplication. (That doesn’t mean I’m suggesting multiplication should be ++ and exponentiation +++; that seems an orthogonalisation too far. And, of course, it’s tricky to define exponentiation as repeated multiplication for arbitrary reals, let alone complexes.)

Anyway, despite the relationship between * and / on the one hand, and * and ** on the other, I’m not aware of any programming language that provides an operator // such that // is to ** as / is to *. What would such an operator do? Preserving the relationship between x, y, and z that obtains for * and /, we’d have x // z == y. Plugging in some values for the variables will simplify this. We know that, for example, 2 ** 10 == 1024. So we then get 2 // 1024 == 10 — which instantly demonstrates that this hypothetical // is a reverse logarithm operator. We might therefore consider pronouncing expr // as “the base expr logarithm of”, or simply “the expr log of”.

Of course, having come up with this idea, I think it’s only fair that I be expected to produce an implementation for at least one programming language. Here’s one in Haskell:

import Prelude (Floating, flip, logBase)

(//) :: Floating a => a -> a -> a
(//) = flip logBase

I find it particularly pleasing how this definition exposes the relationship between // and logBase, but maybe I’m just easily pleased.


While I can’t find any language with this sort of // operator, it turns out that APL has something very similar. APL uses × for multiplication and ÷ for division, so the analogy with those doesn’t hold. But APL does use (a star operator) for exponentiation, and (circled star) for logarithms. In accordance with the APL nature, each of those exists in both a monadic and a dyadic form; in the monadic form, the base is e ≅ 2.718, the base of natural logarithms. But APL requires monadic operators to be prefix rather than postfix, so to maintain the property that both ⍟x and b⍟x treat x as the number whose logarithm is being taken, we require that the base must be the left-hand argument in the dyadic version. Which means that APL dyadic is precisely my hypothetical // operator.