A lot of times, it helps to check if there’s a function for even the most basic operations when learning a new language. I just found out that Clojure has a function for integer division, and I’ve been doing it the hard way this whole time!

### How I’ve been doing it

I’ve just been doing normal division, then converting the result to an int. While this works fine, it has a couple problems. First is clunkiness; if I decide to use this in my high-level functions, they can quickly get polluted with the integer division logic.

``````(defn oreos-per-student []
(let [oreos 10
students 3]
(int (/ oreos students))))
``````

Of course, this could be easily solved by just creating a function for integer division, but that’s where the second problem comes in. What on earth would I name an integer division function? `div-int`, `int-div`, `integer-division`? It almost seems better to just leave the logic in the higher-level function.

### How Clojure does it

Clojure as a much more elegant way of performing integer division. `quot` (not to be confused with `quote`) refers to the “quotient” of two numbers, and will perform the integer division we need. So our new and improved function now looks like this:

``````(defn oreos-per-student []
(let [oreos 10
students 3]
(quot oreos students)))
``````

### What is a Quotient?

You may be asking yourself, “Isn’t the quotient of a number just regular division?” Well, yeah… it is. But words are hard, so the quotient used here is taken in a different context.

In mathematics, the quotient of 7 and 2 is 3.5. In that sense, the quotient would just be regular division. But we could also say that 7 divided by 2 gives us a quotient of 3 with a remainder of 1. This is the context that quotient is being used in; it takes the integer part of the division and drops the remainder.

### Is it Fast?

I haven’t measured the speed, but I would think that `quot` would be faster than performing normal division and casting to an int. Firstly, both `/` and `quot` pass the operands directly into lower-level Java functions for their operations, which in turn pass the operands to even lower-level functions.

If we assume that `quot` and `/` perform at approximately the same speed, then adding an integer cast on top of that would only slow things down.

Additionally, I’m sure that integer casting was on the table when the original developers were writing the `quot` function, so there’s probably a reason they favored the use of Java’s quotient function over integer casting.

### Edit: More on Performance

A coworker of mine created a benchmark function and sent me the results of the different division methods discussed above. Check out his blog post on how the function works! It’s very useful for a lot of scenarios.

In his results, we can see that `quot` is almost four times faster than `/`! Crazy, right? I would have thought these would be just about the same. Not only that though, `quot` is almost seven times faster than our original integer-division method! This can make a huge difference when executing an operation millions, or even hundreds of thousands of times.

``````(perf/benchmark 10 100000 "(int (/ 101 10))" #(int (/ 101 10)))
(perf/benchmark 10 100000 "(/ 101 10)      " #(/ 101 10))
(perf/benchmark 10 100000 "(quot 101 10)   " #(quot 101 10))
``````
``````## (int (/ 101 10)) - 10 x 100000 ops, average per-op: 183ns
## (/ 101 10)       - 10 x 100000 ops, average per-op: 96ns
## (quot 101 10)    - 10 x 100000 ops, average per-op: 27ns
``````