Étude 7-1: Rational Numbers

Clojure has rational numbers; if you enter (/ 6 8) in the REPL, you get back 3/4. ClojureScript doesn’t do that, so you will implement rational numbers by adding the minus, mul, and div methods to the SpecialNumbers protocol. You will then define a record named Rational for holding a rational number using its numerator and denominator. Implement all the methods of the protocol for rational numbers (including canonical and toString).

The canonical form of a rational number is the fraction reduced to lowest terms, with the denominator always positive; thus:

proto.core=> (canonical (Rational. 6 8))
#proto.core.Rational{:num 3, :denom 4}
proto.core=> (canonical (Rational. 6 -9))
#proto.core.Rational{:num -2, :denom 3}

To reduce a fraction, you divide its numerator and denominator by the greatest common divisor (GCD) of the two numbers. The GCD is defined only for positive numbers. Here is Dijkstra’s algorithm for GCD of numbers m and n:

• If m equals n, return m.
• If m is greater than n, return the GCD of (m − n) and n.
• Otherwise, return the GCD of m and (n − m).

The cool thing about this algorithm for finding the greatest common divisor is that it doesn’t do any division at all! Notice that it is recursively defined, so this is a wonderful place for you to learn to use recur. (Hint: cond is also quite useful here.)

When converting to canonical form, if you have a zero in the numerator, just keep the rational number exactly as it is.

See a suggested solution: Solution 7-1.

Étude 7-2: Complex Numbers

Extend this project further by adding a record and protocol for complex numbers. A complex number has the form a + bi, where a is the real part and b is the imaginary part. The letter i stands for the square root of negative 1.:

Here are formulas for doing arithmetic on complex numbers.

The canonical form of a complex number is just itself. Here is what conversion of complex numbers to strings should look like:

proto.core=> (str (Complex. 3 7))
"3+7i"
proto.core=> (str (Complex. 3 -7))
"3-7i"
proto.core=> (str (Complex. 3 0))
"3"
proto.core=> (str (Complex. 0 3))
"3i"
proto.core=> (str (Complex. 0 -3))
"-3i"
proto.core=> (str (Complex. 0 7))
"7i"
proto.core=> (str (Complex. 0 -7))
"-7i"

See a suggested solution: Solution 7-2.

Étude 7-3: Writing Tests

Through the book so far, I have been very lax in writing unit tests for my code. At least for this chapter, that changes.

Many projects put their tests in a separate test folder, so you should create one now, and, inside of it, make a file named test_cases.cljs. Then give it these contents (they presume that your project is named proto).

(ns ^:figwheel-always test.test-cases
  (:require-macros [cljs.test :refer [deftest is are]])
  (:require [cljs.test :as t]
            [proto.core :as p]))

Notice that the namespace is test-cases; the file name is translated to test_cases.

The ^:figwheel-always is metadata that tells Figwheel to reload the code on every change to the file.

The :require-macros is something new; macros are like functions, except that they generate ClojureScript code. The three macros that you will use are deftest, is, and are. First, let’s define a test that will check that the canonical form of 3 minutes and 84 seconds is 4 minutes and 24 seconds.

(deftest duration1
  (is (= (p/canonical (p/Duration. 3 84)) (p/Duration. 4 24))))

The deftest macro creates the test, and the is macro makes a testable assertion; the body of is should yield a boolean value. You can run tests from the REPL.

cljs.user=> (in-ns 'proto.core)
nil
proto.core=> (require '[cljs.test :as t])
nil
proto.core=> (t/run-tests 'test.test-cases)

Testing test.test-cases

Ran 1 tests containing 1 assertions.
0 failures, 0 errors.
nil

If you want to test several additions, you could write several different deftests, but if they all follow the same model, you can use are, which is followed by a vector of parameter names, an expression to evaluate (which can contain let), and then a series of sets of arguments to be evaluated. In the following example, the parameter names vector is on the first line, the second and third line are the expression to evaluate, and the remaining lines are sets of arguments to assert. (Thus, the first set will plug in 1 for m1, 10 for s1,and "1:10" for expected and then test the expression with those values.)

(deftest duration-str
  (are [m1 s1 expected]
    (= (str (p/Duration. m1 s1) expected))
    1 10  "1:10"
    1 9 "1:09"
    1 60 "2:00"
    3 145 "5:25"
    0 0 "0:00")

In this étude, you will write a series of tests for the rational and complex numbers. As you will note, some of the tests I used for durations were designed to try “edge cases” in the hopes of making the algorithms fail. Here are some of the things you might consider testing:

See a suggested solution: Solution 7-3.