diff --git a/bower.json b/bower.json
index 04b063e..3ca625d 100644
--- a/bower.json
+++ b/bower.json
@@ -12,6 +12,7 @@
     "purescript-either": "^3.2.0",
     "purescript-exceptions": "^3.0.0",
     "purescript-tuples-native": "^0.1.0",
+    "purescript-integers": "^3.2.0",
     "purescript-record": "git@github.com:athanclark/purescript-record.git#850360dbfa1bf765a19b3ec207a706622fa47ac7"
   },
   "repository": {
diff --git a/src/Data/BigNumber.js b/src/Data/BigNumber.js
index ab7ee76..546b5ce 100644
--- a/src/Data/BigNumber.js
+++ b/src/Data/BigNumber.js
@@ -23,16 +23,120 @@ exports.isBigNumber = function isBigNumber (x) {
 };
 
 
-exports.maxBigNumberImpl = function maxBigNumberImpl (x,y) {
-    return BigNumber.maximum(x,y);
-};
-
-
-exports.minBigNumberImpl = function minBigNumberImpl (x,y) {
-    return BigNumber.minimum(x,y);
-};
-
-
 exports.randomBigNumber = function randomBigNumber () {
     return BigNumber.random();
 };
+
+
+exports.absBigNumber = function absBigNumber (x) {
+    return x.abs();
+};
+
+
+exports.compareBigNumberImpl = function compareBigNumberImpl (LT,EQ,GT,x,y) {
+    var r = x.comparedTo(y);
+    if (r === -1) {
+        return LT;
+    } else if (r === 0) {
+        return EQ;
+    } else if (r === 1) {
+        return GT;
+    }
+};
+
+
+exports.divBigNumberImpl = function divBigNumberImpl (x,y) {
+    return x.div(y);
+};
+
+exports.idivBigNumberImpl = function idivBigNumberImpl (x,y) {
+    return x.idiv(y);
+};
+
+exports.powBigNumberImpl = function powBigNumberImpl (x,y) {
+    return x.pow(y);
+};
+
+exports.intValue = function intValue (x) {
+    return x.integerValue();
+};
+
+exports.eqBigNumberImpl = function eqBigNumberImpl (x,y) {
+    return x.eq(y);
+};
+
+exports.isFinite = function isFinite (x) {
+    return x.isFinite();
+};
+
+exports.gtBigNumberImpl = function gtBigNumberImpl (x,y) {
+    return x.gt(y);
+};
+
+exports.gteBigNumberImpl = function gteBigNumberImpl (x,y) {
+    return x.gte(y);
+};
+
+exports.isInteger = function isInteger (x) {
+    return x.isInteger();
+};
+
+exports.ltBigNumberImpl = function ltBigNumberImpl (x,y) {
+    return x.lt(y);
+};
+
+exports.lteBigNumberImpl = function lteBigNumberImpl (x,y) {
+    return x.lte(y);
+};
+
+exports.isNaN = function isNaN (x) {
+    return x.isNaN();
+};
+
+exports.isNegative = function isNegative (x) {
+    return x.isNegative();
+};
+
+exports.isPositive = function isPositive (x) {
+    return x.isPositive();
+};
+
+exports.isZero = function isZero (x) {
+    return x.isZero();
+};
+
+exports.minusBigNumberImpl = function minusBigNumberImpl (x,y) {
+    return x.minus(y);
+};
+
+exports.moduloBigNumberImpl = function moduloBigNumberImpl (x,y) {
+    return x.modulo(y);
+};
+
+exports.timesBigNumberImpl = function timesBigNumberImpl (x,y) {
+    return x.times(y);
+};
+
+exports.negateBigNumber = function negateBigNumber (x) {
+    return x.negated();
+};
+
+exports.plusBigNumberImpl = function plusBigNumberImpl (x,y) {
+    return x.plus(y);
+};
+
+exports.precisionBigNumberImpl = function precisionBigNumberImpl (x,y) {
+    return x.precision(y);
+};
+
+exports.toNumber = function toNumber (x) {
+    return x.toNumber();
+};
+
+exports.toString = function toString (x) {
+    return x.toString();
+};
+
+exports.sqrt = function sqrt (x) {
+    return x.sqrt();
+};
diff --git a/src/Data/BigNumber.purs b/src/Data/BigNumber.purs
index e97f8c8..a956cc9 100644
--- a/src/Data/BigNumber.purs
+++ b/src/Data/BigNumber.purs
@@ -5,17 +5,20 @@ module Data.BigNumber
   , roundHalfUp, roundHalfDown, roundHalfEven, roundHalfCeil, roundHalfFloor
   , ModuloMode, modRoundUp, modRoundDown, modRoundFloor, modRoundHalfEven
   , modEuclid
-  , isBigNumber, maxBigNumber, minBigNumber, randomBigNumber
+  , isBigNumber, randomBigNumber
   ) where
 
 import Prelude
+import Data.Int as Int
 import Data.Either (Either (..))
-import Data.Function.Uncurried (Fn3, runFn3, Fn2, runFn2)
+import Data.Function.Uncurried (Fn3, runFn3, Fn2, runFn2, Fn5, runFn5)
 import Data.Record.Class (class Subrow)
 import Data.Tuple.Native (T2)
+-- import Data.Semiring (class Semiring)
 import Control.Monad.Eff (Eff, kind Effect)
 import Control.Monad.Eff.Exception (Error)
 import Control.Monad.Eff.Uncurried (EffFn1, runEffFn1)
+import Partial.Unsafe (unsafePartial)
 
 
 foreign import data BIGNUMBER :: Effect
@@ -85,15 +88,63 @@ config = runEffFn1 configImpl
 
 
 foreign import isBigNumber :: forall a. a -> Boolean
-
-foreign import maxBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
-
-maxBigNumber :: BigNumber -> BigNumber -> BigNumber
-maxBigNumber = runFn2 maxBigNumberImpl
-
-foreign import minBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
-
-minBigNumber :: BigNumber -> BigNumber -> BigNumber
-minBigNumber = runFn2 minBigNumberImpl
-
 foreign import randomBigNumber :: forall eff. Eff (bigNumber :: BIGNUMBER | eff) BigNumber
+foreign import compareBigNumberImpl :: Fn5 Ordering Ordering Ordering BigNumber BigNumber Ordering
+foreign import absBigNumber :: BigNumber -> BigNumber
+foreign import divBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import idivBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import powBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import intValue :: BigNumber -> BigNumber
+foreign import eqBigNumberImpl :: Fn2 BigNumber BigNumber Boolean
+foreign import isFinite :: BigNumber -> Boolean
+foreign import gtBigNumberImpl :: Fn2 BigNumber BigNumber Boolean
+foreign import gteBigNumberImpl :: Fn2 BigNumber BigNumber Boolean
+foreign import isInteger :: BigNumber -> Boolean
+foreign import ltBigNumberImpl :: Fn2 BigNumber BigNumber Boolean
+foreign import lteBigNumberImpl :: Fn2 BigNumber BigNumber Boolean
+foreign import isNaN :: BigNumber -> Boolean
+foreign import isNegative :: BigNumber -> Boolean
+foreign import isPositive :: BigNumber -> Boolean
+foreign import isZero :: BigNumber -> Boolean
+foreign import plusBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import minusBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import moduloBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import timesBigNumberImpl :: Fn2 BigNumber BigNumber BigNumber
+foreign import negateBigNumber :: BigNumber -> BigNumber
+foreign import precisionBigNumberImpl :: Fn2 BigNumber Int BigNumber
+foreign import toNumber :: BigNumber -> Number
+foreign import toString :: BigNumber -> String
+foreign import sqrt :: BigNumber -> BigNumber
+
+
+instance eqBigNumber :: Eq BigNumber where
+  eq = runFn2 eqBigNumberImpl
+
+instance ordBigNumber :: Ord BigNumber where
+  compare = runFn5 compareBigNumberImpl LT EQ GT
+
+instance showBigNumber :: Show BigNumber where
+  show = toString
+
+instance semiringBigNumber :: Semiring BigNumber where
+  add = runFn2 plusBigNumberImpl
+  zero = unsafePartial $ case parseBigNumber "0" of
+    Right x -> x
+  one = unsafePartial $ case parseBigNumber "1" of
+    Right x -> x
+  mul = runFn2 timesBigNumberImpl
+
+instance ringBigNumber :: Ring BigNumber where
+  sub = runFn2 minusBigNumberImpl
+
+instance commutativeRingBigNumber :: CommutativeRing BigNumber
+
+instance divisionRingBigNumber :: DivisionRing BigNumber where
+  recip = runFn2 divBigNumberImpl one
+
+instance euclideanRingBigNumber :: EuclideanRing BigNumber where
+  degree = Int.floor <<< toNumber <<< intValue <<< absBigNumber
+  div = runFn2 divBigNumberImpl
+  mod = runFn2 moduloBigNumberImpl
+
+instance fieldBigNumber :: Field BigNumber