Let's implement a data type like `Data.Ratio`

of `Haskell`

in Standard ML that will handle rational numbers (with greater precision than floating point).

## signature

```
signature RATIO =
sig
type ratio = int * int
exception DivideByZero
val fromIntPair : int * int -> ratio
val + : ratio * ratio -> ratio
val - : ratio * ratio -> ratio
val * : ratio * ratio -> ratio
val / : ratio * ratio -> ratio
val > : ratio * ratio -> bool
val < : ratio * ratio -> bool
end
```

The name of data type is `ratio`

. It is actually a couple of integer.

Prepare conversion functions `fromIntPair`

, addition, subtraction, multiplication and division of fractions, and comparison operations.

In practice this is a couple of integer, so use `=`

for the equal sign.

## structure

```
structure Ratio : RATIO =
struct
type ratio = int * int
exception DivideByZero
fun fromIntPair (num, 0) = raise DivideByZero
| fromIntPair (0, den) = (0, 1)
| fromIntPair (num, den) =
let fun gcd (x, y) = if x = y then x
else if x > y then gcd (x - y, y)
else gcd (x, y - x)
val g = if den > 0 then gcd (abs num, abs den)
else ~(gcd (abs num, abs den))
in (num div g, den div g)
end
fun (x, y) + (z, w) = fromIntPair (Int.+(Int.*(w, x), Int.*(y, z)), Int.*(y, w))
fun (x, y) - (z, w) = fromIntPair (Int.-(Int.*(w, x), Int.*(y, z)), Int.*(y, w))
fun (x, y) * (z, w) = fromIntPair (Int.*(x, z), Int.*(y, w))
fun (x, y) / (z, w) = fromIntPair (Int.*(x, w), Int.*(y, z))
fun (x, y) > (z, w) = Int.>(Int.*(w, x), Int.*(y, z))
fun (x, y) < (z, w) = Int.<(Int.*(w, x), Int.*(y, z))
end
```

The argument to `fromIntPair`

will call an exception if the denominator is 0, and return `(0, 1)`

if the numerator is 0.

Otherwise, the greatest common divisor is obtained by taking the absolute value and dividing by the greatest common divisor obtained by the numerator and the denominator.

If the denominator is negative, the sign is reversed because only the numerator is signed.

In the four arithmetic operations of fractions, the numerator is calculated with the denominator aligned and then reduced with `fromIntPair`

.

In comparison operations, the numerators are compared after the denominators are aligned.

## examples of execution

Use `open`

to expand a structure, and use `local`

to avoid hiding the constraints of the original four operations and comparisons.

```
- local open Ratio
= in
= val twoThird =
= let val oneThird = fromIntPair (1, 3)
= in oneThird + oneThird
= end
= end
= ;
val twoThird = (2,3) : int * int
```

## Discussion (0)