Task

Create a reasonably complete implementation of rational arithmetic in the particular language using the idioms of the language.



Example

Define a new type called frac with binary operator "//" of two integers that returns a structure made up of the numerator and the denominator (as per a rational number).

Further define the appropriate rational unary operators abs and '-', with the binary operators for addition '+', subtraction '-', multiplication '×', division '/', integer division '÷', modulo division, the comparison operators (e.g. '<', '≤', '>', & '≥') and equality operators (e.g. '=' & '≠').

Define standard coercion operators for casting int to frac etc.

If space allows, define standard increment and decrement operators (e.g. '+:=' & '-:=' etc.).

Finally test the operators:
Use the new type frac to find all perfect numbers less than 219 by summing the reciprocal of the factors.



Related task

   Perfect Numbers


-- parent script "Frac"
property num
property denom
 
----------------------------------------
-- @constructor
-- @param {integer} numerator
-- @param {integer} [denominator=1]
----------------------------------------
on new (me, numerator, denominator)
  if voidP(denominator) then denominator = 1
  if denominator=0 then return VOID -- rule out division by zero
  g = me._gcd(numerator, denominator)
  if g<>0 then
    numerator = numerator/g
    denominator = denominator/g
  else
    numerator = 0
    denominator = 1
  end if
  if denominator<0 then
    numerator = -numerator
    denominator = -denominator
  end if
  me.num = numerator
  me.denom = denominator
  return me
end
 
----------------------------------------
-- Returns string representation "<num>/<denom>"
-- @return {string}
----------------------------------------
on toString (me)
  return me.num&"/"&me.denom
end
 
----------------------------------------
--
----------------------------------------
on _gcd (me, a, b)
  if a = 0 then return b
  if b = 0 then return a
  if a > b then return me._gcd(b, a mod b)
  return me._gcd(a, b mod a)
end