diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -56,6 +56,9 @@
 ghci:
 	$(HCI) -Wall -i:src:test +RTS -M256m -c30 -RTS test/Test.hs
 
+ghci7:
+	$(HCI) -Wall -i:src:test -XCPP -DNoImplicitPrelude=RebindableSyntax +RTS -M256m -c30 -RTS test/Test.hs
+
 ghci-gauss:
 	$(HCI) -Wall -i:src:test +RTS -M256m -c30 -RTS test/Test/MathObj/Gaussian/Variance.hs
 
diff --git a/numeric-prelude.cabal b/numeric-prelude.cabal
--- a/numeric-prelude.cabal
+++ b/numeric-prelude.cabal
@@ -1,5 +1,5 @@
 Name:           numeric-prelude
-Version:        0.3.0.2
+Version:        0.4
 License:        GPL
 License-File:   LICENSE
 Author:         Dylan Thurston <dpt@math.harvard.edu>, Henning Thielemann <numericprelude@henning-thielemann.de>, Mikael Johansson
@@ -8,7 +8,7 @@
 Category:       Math
 Stability:      Experimental
 Tested-With:    GHC==6.4.1, GHC==6.8.2, GHC==6.10.4, GHC==6.12.3
-Tested-With:    GHC==7.2.2, GHC==7.4.1
+Tested-With:    GHC==7.2.2, GHC==7.4.1, GHC==7.6.3
 Cabal-Version:  >=1.6
 Build-Type:     Simple
 Synopsis:       An experimental alternative hierarchy of numeric type classes
@@ -154,7 +154,7 @@
   default:     False
 
 Source-Repository this
-  Tag:         0.3.0.2
+  Tag:         0.4
   Type:        darcs
   Location:    http://code.haskell.org/numeric-prelude/
 
@@ -193,6 +193,7 @@
     Algebra.DimensionTerm
     Algebra.DivisibleSpace
     Algebra.Field
+    Algebra.FloatingPoint
     Algebra.Indexable
     Algebra.IntegralDomain
     Algebra.NonNegative
@@ -338,7 +339,7 @@
     MathObj.Gaussian.Example
   If flag(buildTests)
     Build-Depends:
-      gnuplot >=0.3 && <0.5,
+      gnuplot >=0.5 && <0.6,
       HTam >=0.0.2 && <0.1
   Else
     Buildable: False
diff --git a/src/Algebra/Additive.hs b/src/Algebra/Additive.hs
--- a/src/Algebra/Additive.hs
+++ b/src/Algebra/Additive.hs
@@ -32,6 +32,7 @@
 import Data.Tuple.HT (fst3, snd3, thd3, )
 import qualified Data.List.Match as Match
 
+import qualified Data.Complex as Complex98
 import qualified Data.Ratio as Ratio98
 import qualified Prelude as P
 import Prelude (Integer, Float, Double, fromInteger, )
@@ -405,7 +406,17 @@
    {-# INLINE negate #-}
    {-# INLINE (+) #-}
    {-# INLINE (-) #-}
-   zero                =  0
+   zero                =  P.fromInteger 0
+   (+)                 =  (P.+)
+   (-)                 =  (P.-)
+   negate              =  P.negate
+
+instance (P.RealFloat a) => C (Complex98.Complex a) where
+   {-# INLINE zero #-}
+   {-# INLINE negate #-}
+   {-# INLINE (+) #-}
+   {-# INLINE (-) #-}
+   zero                =  P.fromInteger 0
    (+)                 =  (P.+)
    (-)                 =  (P.-)
    negate              =  P.negate
diff --git a/src/Algebra/Field.hs b/src/Algebra/Field.hs
--- a/src/Algebra/Field.hs
+++ b/src/Algebra/Field.hs
@@ -16,12 +16,11 @@
 
 import Number.Ratio (T((:%)), Rational, (%), numerator, denominator, )
 import qualified Number.Ratio as Ratio
+import qualified Data.Complex as Complex98
 import qualified Data.Ratio as Ratio98
 import qualified Algebra.PrincipalIdealDomain as PID
-import qualified Algebra.Units as Unit
 
 import qualified Algebra.Ring         as Ring
--- import qualified Algebra.Additive     as Additive
 import qualified Algebra.ZeroTestable as ZeroTestable
 
 import Algebra.Ring ((*), (^), one, fromInteger)
@@ -136,10 +135,7 @@
 
     recip (x:%y)         =  (y:%x)
 -}
-    recip (x:%y)         =
-       if isZero y
-         then error "Ratio./: division by zero"
-         else (y * Unit.stdUnitInv x) :% Unit.stdAssociate x
+    recip = Ratio.recip
     fromRational' (x:%y) =  fromInteger x % fromInteger y
 
 
@@ -155,6 +151,12 @@
 -- legacy
 
 instance (P.Integral a) => C (Ratio98.Ratio a) where
+    {-# INLINE (/) #-}
+    {-# INLINE recip #-}
+    (/)    = (P./)
+    recip  = (P.recip)
+
+instance (P.RealFloat a) => C (Complex98.Complex a) where
     {-# INLINE (/) #-}
     {-# INLINE recip #-}
     (/)    = (P./)
diff --git a/src/Algebra/FloatingPoint.hs b/src/Algebra/FloatingPoint.hs
new file mode 100644
--- /dev/null
+++ b/src/Algebra/FloatingPoint.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+module Algebra.FloatingPoint where
+
+import qualified Algebra.RealRing as RealRing
+import NumericPrelude.Base
+
+import qualified Prelude as P
+import Prelude (Int, Integer, Float, Double, )
+
+
+{- |
+Counterpart of 'Prelude.RealFloat' but with NumericPrelude superclass.
+-}
+class RealRing.C a => C a where
+   radix :: a -> Integer
+   digits :: a -> Int
+   range :: a -> (Int, Int)
+   decode :: a -> (Integer, Int)
+   encode :: Integer -> Int -> a
+   exponent :: a -> Int
+   significand :: a -> a
+   scale :: Int -> a -> a
+   isNaN :: a -> Bool
+   isInfinite :: a -> Bool
+   isDenormalized :: a -> Bool
+   isNegativeZero :: a -> Bool
+   isIEEE :: a -> Bool
+
+instance C Float where
+   radix = P.floatRadix
+   digits = P.floatDigits
+   range = P.floatRange
+   decode = P.decodeFloat
+   encode = P.encodeFloat
+   exponent = P.exponent
+   significand = P.significand
+   scale = P.scaleFloat
+   isNaN = P.isNaN
+   isInfinite = P.isInfinite
+   isDenormalized = P.isDenormalized
+   isNegativeZero = P.isNegativeZero
+   isIEEE = P.isIEEE
+
+instance C Double where
+   radix = P.floatRadix
+   digits = P.floatDigits
+   range = P.floatRange
+   decode = P.decodeFloat
+   encode = P.encodeFloat
+   exponent = P.exponent
+   significand = P.significand
+   scale = P.scaleFloat
+   isNaN = P.isNaN
+   isInfinite = P.isInfinite
+   isDenormalized = P.isDenormalized
+   isNegativeZero = P.isNegativeZero
+   isIEEE = P.isIEEE
diff --git a/src/Algebra/OccasionallyScalar.hs b/src/Algebra/OccasionallyScalar.hs
--- a/src/Algebra/OccasionallyScalar.hs
+++ b/src/Algebra/OccasionallyScalar.hs
@@ -27,15 +27,8 @@
 
 module Algebra.OccasionallyScalar where
 
--- import qualified Algebra.RealRing    as RealRing
-import qualified Algebra.ZeroTestable as ZeroTestable
-import qualified Algebra.Additive     as Additive
-import qualified Number.Complex       as Complex
-
 import Data.Maybe (fromMaybe, )
 
-import Number.Complex((+:))
-
 import NumericPrelude.Base
 import NumericPrelude.Numeric
 
@@ -66,14 +59,6 @@
    toScalar      = id
    toMaybeScalar = Just
    fromScalar    = id
-
--- this instance should be defined in Number.Complex
-instance (Show v, ZeroTestable.C v, Additive.C v, C a v) => C a (Complex.T v) where
-   toScalar        = toScalarShow
-   toMaybeScalar x = if isZero (Complex.imag x)
-                       then toMaybeScalar (Complex.real x)
-                       else Nothing
-   fromScalar x    = fromScalar x +: zero
 
 {- converting values automatically to integers is a bad idea
 instance (Integral b, RealRing.C a)
diff --git a/src/Algebra/Ring.hs b/src/Algebra/Ring.hs
--- a/src/Algebra/Ring.hs
+++ b/src/Algebra/Ring.hs
@@ -38,6 +38,7 @@
 
 import NumericPrelude.Base
 import Prelude (Integer, Float, Double, )
+import qualified Data.Complex as Complex98
 import qualified Data.Ratio as Ratio98
 import qualified Prelude as P
 -- import Test.QuickCheck
@@ -252,6 +253,14 @@
    {-# INLINE one #-}
    {-# INLINE fromInteger #-}
    {-# INLINE (*) #-}
-   one                 =  1
+   one                 =  P.fromInteger 1
+   fromInteger         =  P.fromInteger
+   (*)                 =  (P.*)
+
+instance (P.RealFloat a) => C (Complex98.Complex a) where
+   {-# INLINE one #-}
+   {-# INLINE fromInteger #-}
+   {-# INLINE (*) #-}
+   one                 =  P.fromInteger 1
    fromInteger         =  P.fromInteger
    (*)                 =  (P.*)
diff --git a/src/MathObj/Matrix.hs b/src/MathObj/Matrix.hs
--- a/src/MathObj/Matrix.hs
+++ b/src/MathObj/Matrix.hs
@@ -18,7 +18,7 @@
 but no additional parameters.
 
 ToDo:
- - Matrix inverse, determinant
+ - Matrix inverse, determinant (see htam:Matrix)
 -}
 
 module MathObj.Matrix (
@@ -71,9 +71,9 @@
 {- |
 A matrix is a twodimensional array, indexed by integers.
 -}
-data T a =
+newtype T a =
    Cons (Array (Dimension, Dimension) a)
-      deriving (Eq,Ord,Read)
+      deriving (Eq, Ord, Read)
 
 type Dimension = Int
 
diff --git a/src/MathObj/Polynomial.hs b/src/MathObj/Polynomial.hs
--- a/src/MathObj/Polynomial.hs
+++ b/src/MathObj/Polynomial.hs
@@ -73,6 +73,8 @@
 
 import Test.QuickCheck (Arbitrary(arbitrary))
 
+import qualified MathObj.Wrapper.Haskell98 as W98
+
 import NumericPrelude.Base    hiding (const, reverse, )
 import NumericPrelude.Numeric
 
@@ -279,7 +281,7 @@
    arbitrary = liftM (fromCoeffs . Core.normalize) arbitrary
 
 
-{- * legacy instances -}
+-- * Haskell 98 legacy instances
 
 {- |
 It is disputable whether polynomials shall be represented by number literals or not.
@@ -288,19 +290,20 @@
 in  (x^2+x+1)*(x-1)
 However the output looks much different.
 -}
-{-# INLINE legacyInstance #-}
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
+{-# INLINE notImplemented #-}
+notImplemented :: String -> a
+notImplemented name =
+   error $ "MathObj.Polynomial: method " ++ name ++ " cannot be implemented"
 
-instance (Ring.C a, Eq a, Show a, ZeroTestable.C a) => P98.Num (T a) where
-   fromInteger = const . fromInteger
-   negate = Additive.negate -- for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+-- legacy instances for use of numeric literals in GHCi
+instance (P98.Num a) => P98.Num (T a) where
+   fromInteger = const . P98.fromInteger
+   negate = W98.unliftF1 Additive.negate
+   (+)    = W98.unliftF2 (Additive.+)
+   (*)    = W98.unliftF2 (Ring.*)
+   abs    = notImplemented "abs"
+   signum = notImplemented "signum"
 
-instance (Field.C a, Eq a, Show a, ZeroTestable.C a) => P98.Fractional (T a) where
-   fromRational = const . fromRational
-   (/) = legacyInstance
+instance (P98.Fractional a) => P98.Fractional (T a) where
+   fromRational = const . P98.fromRational
+   (/) = notImplemented "(/)"
diff --git a/src/MathObj/Wrapper/Haskell98.hs b/src/MathObj/Wrapper/Haskell98.hs
--- a/src/MathObj/Wrapper/Haskell98.hs
+++ b/src/MathObj/Wrapper/Haskell98.hs
@@ -10,6 +10,7 @@
 import qualified Algebra.Additive as Additive
 import qualified Algebra.Algebraic as Algebraic
 import qualified Algebra.Field as Field
+import qualified Algebra.FloatingPoint as Float
 import qualified Algebra.IntegralDomain as Integral
 import qualified Algebra.PrincipalIdealDomain as PID
 import qualified Algebra.RealField as RealField
@@ -43,7 +44,7 @@
 then @T (Polynomial (MathObj.Wrapper.NumericPrelude.T a))@
 is in 'Ring.C' for all types @a@ that are in 'Ring.C'.
 -}
-newtype T a = Cons a
+newtype T a = Cons {decons :: a}
    deriving
       (Show, Eq, Ord, Ix, Bounded, Enum,
        Num, Integral, Fractional, Floating,
@@ -59,6 +60,15 @@
 lift2 f (Cons a) (Cons b) = Cons (f a b)
 
 
+{-# INLINE unliftF1 #-}
+unliftF1 :: Functor f => (f (T a) -> f (T b)) -> f a -> f b
+unliftF1 f a = fmap decons $ f (fmap Cons a)
+
+{-# INLINE unliftF2 #-}
+unliftF2 :: Functor f => (f (T a) -> f (T b) -> f (T c)) -> f a -> f b -> f c
+unliftF2 f a b = fmap decons $ f (fmap Cons a) (fmap Cons b)
+
+
 instance Functor T where
    {-# INLINE fmap #-}
    fmap f (Cons a) = Cons (f a)
@@ -155,6 +165,21 @@
 
 instance (Real a) => ToRational.C (T a) where
    toRational (Cons a) = Field.fromRational (toRational a)
+
+instance (RealFloat a) => Float.C (T a) where
+   radix = floatRadix . decons
+   digits = floatDigits . decons
+   range = floatRange . decons
+   decode = decodeFloat . decons
+   encode m = Cons . encodeFloat m
+   exponent = exponent . decons
+   significand = lift1 significand
+   scale = lift1 . scaleFloat
+   isNaN = isNaN . decons
+   isInfinite = isInfinite . decons
+   isDenormalized = isDenormalized . decons
+   isNegativeZero = isNegativeZero . decons
+   isIEEE = isIEEE . decons
 
 
 
diff --git a/src/MathObj/Wrapper/NumericPrelude.hs b/src/MathObj/Wrapper/NumericPrelude.hs
--- a/src/MathObj/Wrapper/NumericPrelude.hs
+++ b/src/MathObj/Wrapper/NumericPrelude.hs
@@ -11,6 +11,7 @@
 import qualified Algebra.Additive as Additive
 import qualified Algebra.Algebraic as Algebraic
 import qualified Algebra.Field as Field
+import qualified Algebra.FloatingPoint as Float
 import qualified Algebra.IntegralDomain as Integral
 import qualified Algebra.PrincipalIdealDomain as PID
 import qualified Algebra.RealField as RealField
@@ -51,14 +52,14 @@
 then @T (Polynomial (MathObj.Wrapper.Haskell98.T a))@
 is in 'Num' for all types @a@ that are in 'Num'.
 -}
-newtype T a = Cons a
+newtype T a = Cons {decons :: a}
    deriving
       (Show, Eq, Ord, Ix, Bounded, Enum,
        Ring.C, Additive.C, Field.C, Algebraic.C, Trans.C,
        Integral.C, PID.C, Units.C,
        Absolute.C, ZeroTestable.C,
        RealField.C, RealIntegral.C, RealRing.C, RealTrans.C,
-       ToInteger.C, ToRational.C,
+       ToInteger.C, ToRational.C, Float.C,
        Differential.C)
 
 {-# INLINE lift1 #-}
@@ -151,21 +152,21 @@
    truncate (Cons a) = fromInteger (RealRing.truncate a)
    round (Cons a) = fromInteger (RealRing.round a)
 
-instance (Trans.C a, RealRing.C a, ToRational.C a, Absolute.C a, Ord a, Show a) => RealFloat (T a) where
-   atan2 = atan2
-   floatRadix = unimplemented "floatRadix"
-   floatDigits = unimplemented "floatDigits"
-   floatRange = unimplemented "floatRange"
-   decodeFloat = unimplemented "decodeFloat"
-   encodeFloat = unimplemented "encodeFloat"
-   exponent = unimplemented "exponent"
-   significand = unimplemented "significand"
-   scaleFloat = unimplemented "scaleFloat"
-   isNaN = unimplemented "isNaN"
-   isInfinite = unimplemented "isInfinite"
-   isDenormalized = unimplemented "isDenormalized"
-   isNegativeZero = unimplemented "isNegativeZero"
-   isIEEE = unimplemented "isIEEE"
+instance (RealTrans.C a, Float.C a, ToRational.C a, Absolute.C a, Ord a, Show a) => RealFloat (T a) where
+   atan2 = RealTrans.atan2
+   floatRadix = Float.radix . decons
+   floatDigits = Float.digits . decons
+   floatRange = Float.range . decons
+   decodeFloat = Float.decode . decons
+   encodeFloat m = Cons . Float.encode m
+   exponent = Float.exponent . decons
+   significand = lift1 Float.significand
+   scaleFloat = lift1 . Float.scale
+   isNaN = Float.isNaN . decons
+   isInfinite = Float.isInfinite . decons
+   isDenormalized = Float.isDenormalized . decons
+   isNegativeZero = Float.isNegativeZero . decons
+   isIEEE = Float.isIEEE . decons
 
 {-
 instance Additive.C (T a) where
diff --git a/src/Number/Complex.hs b/src/Number/Complex.hs
--- a/src/Number/Complex.hs
+++ b/src/Number/Complex.hs
@@ -54,6 +54,7 @@
 import qualified Algebra.NormedSpace.Sum       as NormedSum
 import qualified Algebra.NormedSpace.Maximum   as NormedMax
 
+import qualified Algebra.OccasionallyScalar as OccScalar
 import qualified Algebra.VectorSpace        as VectorSpace
 import qualified Algebra.Module             as Module
 import qualified Algebra.Vector             as Vector
@@ -81,8 +82,10 @@
 import Control.Applicative (liftA2, )
 
 import Test.QuickCheck (Arbitrary, arbitrary, )
-import Control.Monad (liftM2, )
+import Control.Monad (liftM2, guard, )
 
+import qualified MathObj.Wrapper.Haskell98 as W98
+
 import qualified Prelude as P
 import NumericPrelude.Base
 import NumericPrelude.Numeric hiding (signum, exp, )
@@ -359,7 +362,14 @@
    {-# INLINE norm #-}
    norm x = max (NormedMax.norm (real x)) (NormedMax.norm (imag x))
 
+instance (Show v, ZeroTestable.C v, Additive.C v, OccScalar.C a v) => OccScalar.C a (T v) where
+   toScalar        = OccScalar.toScalarShow
+   toMaybeScalar x =
+      guard (isZero (imag x)) >>
+      OccScalar.toMaybeScalar (real x)
+   fromScalar      = fromReal . OccScalar.fromScalar
 
+
 {-
   In this implementation the complex plane is structured
   as an orthogonal grid induced by the divisor z'.
@@ -545,29 +555,25 @@
 -}
 
 
-{- * legacy instances -}
-
-{-# INLINE legacyInstance #-}
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
+-- * Haskell 98 legacy instances
 
-instance (Ring.C a, Eq a, Show a) => P.Num (T a) where
+-- legacy instances for use of numeric literals in GHCi
+instance (P.Floating a, Eq a) => P.Num (T a) where
    {-# INLINE fromInteger #-}
-   fromInteger = fromReal . fromInteger
+   fromInteger n = Cons (P.fromInteger n) (P.fromInteger 0)
    {-# INLINE negate #-}
-   negate = negate -- for unary minus
+   negate = W98.unliftF1 Additive.negate
    {-# INLINE (+) #-}
-   (+)    = legacyInstance
+   (+)    = W98.unliftF2 (Additive.+)
    {-# INLINE (*) #-}
-   (*)    = legacyInstance
+   (*)    = W98.unliftF2 (Ring.*)
    {-# INLINE abs #-}
-   abs    = legacyInstance
+   abs    = W98.unliftF1 Absolute.abs
    {-# INLINE signum #-}
-   signum = legacyInstance
+   signum = W98.unliftF1 Absolute.signum
 
-instance (Field.C a, Eq a, Show a) => P.Fractional (T a) where
+instance (P.Floating a, Eq a) => P.Fractional (T a) where
    {-# INLINE fromRational #-}
-   fromRational = fromRational
+   fromRational x = Cons (P.fromRational x) (P.fromInteger 0)
    {-# INLINE (/) #-}
-   (/) = legacyInstance
+   (/) = W98.unliftF2 (Field./)
diff --git a/src/Number/FixedPoint/Check.hs b/src/Number/FixedPoint/Check.hs
--- a/src/Number/FixedPoint/Check.hs
+++ b/src/Number/FixedPoint/Check.hs
@@ -176,19 +176,15 @@
 
 
 
--- legacy instances for work with GHCi
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
-
+-- legacy instances for use of numeric literals in GHCi
 instance P98.Num T where
    fromInteger = fromInteger' defltDenominator
-   negate = negate --for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+   negate = negate -- for unary minus
+   (+)    = (+)
+   (*)    = (*)
+   abs    = abs
+   signum = signum
 
 instance P98.Fractional T where
    fromRational = fromRational' defltDenominator . fromRational
-   (/) = legacyInstance
+   (/) = (/)
diff --git a/src/Number/NonNegativeChunky.hs b/src/Number/NonNegativeChunky.hs
--- a/src/Number/NonNegativeChunky.hs
+++ b/src/Number/NonNegativeChunky.hs
@@ -24,8 +24,7 @@
 import qualified Numeric.NonNegative.Class as NonNeg98
 
 import qualified Algebra.NonNegative  as NonNeg
-import qualified Algebra.Field        as Field
-import qualified Algebra.Absolute         as Absolute
+import qualified Algebra.Absolute     as Absolute
 import qualified Algebra.Ring         as Ring
 import qualified Algebra.Additive     as Additive
 import qualified Algebra.ToInteger    as ToInteger
@@ -44,9 +43,10 @@
 
 import NumericPrelude.Numeric
 import NumericPrelude.Base
-import qualified Prelude as P98 (Num(..), Fractional(..), )
 
+import qualified Prelude as P98
 
+
 {- |
 A chunky non-negative number is a list of non-negative numbers.
 It represents the sum of the list elements.
@@ -283,23 +283,46 @@
 
 
 
-{- * legacy instances -}
+-- * Haskell 98 legacy instances
 
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
+fromChunky98_ :: (NonNeg98.C a) => Chunky98.T a -> T a
+fromChunky98_ = Cons . Chunky98.toChunks
 
-instance (Ring.C a, Eq a, Show a, NonNeg.C a) => P98.Num (T a) where
-   fromInteger = fromNumber . fromInteger
-   negate = Additive.negate -- for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+toChunky98_ :: (NonNeg98.C a) => T a -> Chunky98.T a
+toChunky98_ = Chunky98.fromChunks . decons
 
-instance (Field.C a, Eq a, Show a, NonNeg.C a) => P98.Fractional (T a) where
-   fromRational = fromNumber . fromRational
-   (/) = legacyInstance
+fromNumber_ :: a -> T a
+fromNumber_ = Cons . (:[])
+
+{-# INLINE lift98_1 #-}
+lift98_1 ::
+   (NonNeg98.C a, NonNeg98.C b) =>
+   (Chunky98.T a -> Chunky98.T b) -> T a -> T b
+lift98_1 f a = fromChunky98_ (f (toChunky98_ a))
+
+{-# INLINE lift98_2 #-}
+lift98_2 ::
+   (NonNeg98.C a, NonNeg98.C b, NonNeg98.C c) =>
+   (Chunky98.T a -> Chunky98.T b -> Chunky98.T c) -> T a -> T b -> T c
+lift98_2 f a b = fromChunky98_ (f (toChunky98_ a) (toChunky98_ b))
+
+
+{-# INLINE notImplemented #-}
+notImplemented :: String -> a
+notImplemented name =
+   error $ "Number.NonNegativeChunky: method " ++ name ++ " cannot be implemented"
+
+instance (NonNeg98.C a, P98.Num a) => P98.Num (T a) where
+   fromInteger = fromNumber_ . P98.fromInteger
+   negate = lift98_1 P98.negate
+   (+)    = lift98_2 (P98.+)
+   (*)    = lift98_2 (P98.*)
+   abs    = lift98_1 P98.abs
+   signum = lift98_1 P98.signum
+
+instance (NonNeg98.C a, P98.Fractional a) => P98.Fractional (T a) where
+   fromRational = fromNumber_ . P98.fromRational
+   (/) = notImplemented "(/)"
 
 instance (NonNeg.C a) => Mn98.Monoid (T a) where
    mempty  = Monoid.idt
diff --git a/src/Number/PartiallyTranscendental.hs b/src/Number/PartiallyTranscendental.hs
--- a/src/Number/PartiallyTranscendental.hs
+++ b/src/Number/PartiallyTranscendental.hs
@@ -2,9 +2,9 @@
 {- |
 Define Transcendental functions on arbitrary fields.
 These functions are defined for only a few (in most cases only one) arguments,
-that's why discourage making these types instances of 'Algebra.Transcendental.C'.
+that's why we discourage making these types instances of 'Algebra.Transcendental.C'.
 But instances of 'Algebra.Transcendental.C' can be useful when working with power series.
-If you intent to work with power series with 'Rational' coefficients,
+If you intend to work with power series with 'Rational' coefficients,
 you might consider using @MathObj.PowerSeries.T (Number.PartiallyTranscendental.T Rational)@
 instead of @MathObj.PowerSeries.T Rational@.
 -}
@@ -17,6 +17,8 @@
 import qualified Algebra.Additive       as Additive
 -- import qualified Algebra.ZeroTestable   as ZeroTestable
 
+import qualified MathObj.Wrapper.Haskell98 as W98
+
 import NumericPrelude.Numeric
 import NumericPrelude.Base
 
@@ -74,18 +76,14 @@
 
 
 
-legacyInstance :: a
-legacyInstance = error "legacy Ring instance for simple input of numeric literals"
-
-
 instance (P.Num a) => P.Num (T a) where
-   fromInteger n = lift0 $ P.fromInteger n
-   negate = P.negate -- for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+   fromInteger = lift0 . P.fromInteger
+   negate = lift1 P.negate
+   (+)    = lift2 (P.+)
+   (-)    = lift2 (P.-)
+   abs    = lift1 P.abs
+   signum = lift1 P.signum
 
-instance (P.Num a) => P.Fractional (T a) where
+instance (P.Fractional a) => P.Fractional (T a) where
    fromRational = P.fromRational
-   (/) = legacyInstance
+   (/) = lift2 (P./)
diff --git a/src/Number/Peano.hs b/src/Number/Peano.hs
--- a/src/Number/Peano.hs
+++ b/src/Number/Peano.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {- |
-Copyright    :   (c) Henning Thielemann 2007
+Copyright    :   (c) Henning Thielemann 2007-2012
 Maintainer   :   numericprelude@henning-thielemann.de
 Stability    :   provisional
 Portability  :   portable
@@ -403,9 +403,10 @@
 
 
 
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
+{-# INLINE notImplemented #-}
+notImplemented :: String -> a
+notImplemented name =
+   error $ "Number.Peano: method " ++ name ++ " cannot be implemented"
 
 instance P98.Num T where
    fromInteger = Ring.fromInteger
@@ -413,8 +414,8 @@
    (+) = add
    (-) = sub
    (*) = mul
-   signum = legacyInstance
-   abs = legacyInstance
+   abs    = notImplemented "abs"
+   signum = notImplemented "signum"
 
 -- for use with genericLength et.al.
 instance P98.Real T where
diff --git a/src/Number/Positional/Check.hs b/src/Number/Positional/Check.hs
--- a/src/Number/Positional/Check.hs
+++ b/src/Number/Positional/Check.hs
@@ -237,22 +237,18 @@
 
 
 
--- legacy instances for work with GHCi
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
-
+-- legacy instances for use of numeric literals in GHCi
 instance P98.Num T where
    fromInteger = fromBaseInteger defltBase
-   negate = negate --for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+   negate = negate -- for unary minus
+   (+)    = (+)
+   (*)    = (*)
+   abs    = abs
+   signum = signum
 
 instance P98.Fractional T where
    fromRational = fromBaseRational defltBase . fromRational
-   (/) = legacyInstance
+   (/) = (/)
 
 
 {-
diff --git a/src/Number/Ratio.hs b/src/Number/Ratio.hs
--- a/src/Number/Ratio.hs
+++ b/src/Number/Ratio.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {- |
 Module      :  Number.Ratio
-Copyright   :  (c) Henning Thielemann, Dylan Thurston 2006
+Copyright   :  (c) Henning Thielemann 2011-2012
+               (c) Dylan Thurston 2006
 
 Maintainer  :  numericprelude@henning-thielemann.de
 Stability   :  provisional
@@ -15,6 +16,7 @@
 	  T((:%), numerator, denominator), (%),
           Rational,
           fromValue,
+          recip,
 
           scale,
           split,
@@ -24,6 +26,7 @@
         )  where
 
 import qualified Algebra.PrincipalIdealDomain as PID
+import qualified Algebra.Units                as Unit
 import qualified Algebra.Absolute             as Absolute
 import qualified Algebra.Ring                 as Ring
 import qualified Algebra.Additive             as Additive
@@ -117,7 +120,13 @@
     abs (x:%y)          =  Absolute.abs x :% y
     signum (x:%_)       =  Absolute.signum x :% one
 
+recip :: (ZeroTestable.C a, Unit.C a) => T a -> T a
+recip (x:%y) =
+   if isZero y
+     then error "Ratio.recip: division by zero"
+     else (y * stdUnitInv x) :% stdAssociate x
 
+
 liftOrd :: Ring.C a => (a -> a -> b) -> (T a -> T a -> b)
 liftOrd f (x:%y) (x':%y') = f (x * y') (x' * y)
 
@@ -222,28 +231,54 @@
 
 -- | Necessary when mixing NumericPrelude.Numeric Rationals with Prelude98 Rationals
 
-toRational98 :: (P.Integral a, PID.C a) => T a -> Ratio98.Ratio a
+toRational98 :: (P.Integral a) => T a -> Ratio98.Ratio a
 toRational98 x = numerator x Ratio98.% denominator x
 
+fromRational98 :: (P.Integral a) => Ratio98.Ratio a -> T a
+fromRational98 x = Ratio98.numerator x :% Ratio98.denominator x
 
-legacyInstance :: String -> a
-legacyInstance op =
-   error ("Ratio." ++ op ++ ": legacy Ring instance for simple input of numeric literals")
 
+{-# INLINE lift1 #-}
+lift1 ::
+   (P.Integral a, P.Integral b) =>
+   (Ratio98.Ratio a -> Ratio98.Ratio b) -> T a -> T b
+lift1 f a = fromRational98 (f (toRational98 a))
 
--- instance (P.Num a, PID.C a) => P.Num (T a) where
-instance (P.Num a, PID.C a, Absolute.C a) => P.Num (T a) where
+{-# INLINE lift2 #-}
+lift2 ::
+   (P.Integral a, P.Integral b, P.Integral c) =>
+   (Ratio98.Ratio a -> Ratio98.Ratio b -> Ratio98.Ratio c) -> T a -> T b -> T c
+lift2 f a b = fromRational98 (f (toRational98 a) (toRational98 b))
+
+
+instance (P.Integral a) => P.Num (T a) where
+   fromInteger n = P.fromInteger n :% P.fromInteger 1
+   negate = lift1 P.negate
+   (+)    = lift2 (P.+)
+   (*)    = lift2 (P.*)
+   abs    = lift1 P.abs
+   signum = lift1 P.signum
+
+instance (P.Integral a) => P.Fractional (T a) where
+   fromRational x =
+      P.fromInteger (Ratio98.numerator x) :%
+      P.fromInteger (Ratio98.denominator x)
+   (/) = lift2 (P./)
+   recip = lift1 P.recip
+
+{- causes an import cycle
+instance (P.Integral a) => P.Num (T a) where
    fromInteger n = P.fromInteger n % 1
-   negate = negate -- for unary minus
-   (+)    = legacyInstance "(+)"
-   (*)    = legacyInstance "(*)"
-   abs    = Absolute.abs -- needed for Arbitrary instance of NonNegative.Ratio
-   signum = legacyInstance "signum"
+   negate = W98.unliftF1 P.negate
+   (+)    = W98.unliftF2 (+)
+   (*)    = W98.unliftF2 (*)
+   abs    = W98.unliftF1 abs
+   signum = W98.unliftF1 P.signum
 
--- instance (P.Num a, PID.C a) => P.Fractional (T a) where
-instance (P.Num a, PID.C a, Absolute.C a) => P.Fractional (T a) where
+instance (P.Integral a) => P.Fractional (T a) where
 --   fromRational = Field.fromRational
    fromRational x =
       fromInteger (Ratio98.numerator x) :%
       fromInteger (Ratio98.denominator x)
-   (/) = legacyInstance "(/)"
+   recip = recip
+-}
diff --git a/src/Number/ResidueClass/Func.hs b/src/Number/ResidueClass/Func.hs
--- a/src/Number/ResidueClass/Func.hs
+++ b/src/Number/ResidueClass/Func.hs
@@ -11,6 +11,9 @@
 import qualified Algebra.EqualityDecision as EqDec
 
 import Algebra.EqualityDecision ((==?), )
+
+import qualified MathObj.Wrapper.Haskell98 as W98
+
 import NumericPrelude.Base
 import NumericPrelude.Numeric hiding (zero, one, )
 
@@ -82,21 +85,32 @@
 But Prelude.fromInteger requires Prelude.Num instance.
 -}
 
--- legacy instances for work with GHCi
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
+{-# INLINE notImplemented #-}
+notImplemented :: String -> a
+notImplemented name =
+   error $ "ResidueClass.Func: method " ++ name ++ " cannot be implemented"
 
-instance (P.Num a, Integral.C a) => P.Num (T a) where
-   fromInteger = Number.ResidueClass.Func.fromInteger
-   negate = negate --for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
 
+lift98_1 :: (W98.T a -> W98.T a -> W98.T a) -> T a -> T a
+lift98_1 f (Cons x) =
+   Cons $ \m -> W98.decons $ f (W98.Cons m) (W98.Cons $ x m)
+
+lift98_2 :: (W98.T a -> W98.T a -> W98.T a -> W98.T a) -> T a -> T a -> T a
+lift98_2 f (Cons x) (Cons y) =
+   Cons $ \m -> W98.decons $ f (W98.Cons m) (W98.Cons $ x m) (W98.Cons $ y m)
+
+
+-- legacy instances for use of numeric literals in GHCi
+instance (P.Integral a) => P.Num (T a) where
+   fromInteger = Cons . P.mod . P.fromInteger
+   negate = lift98_1 Res.neg
+   (+)    = lift98_2 Res.add
+   (*)    = lift98_2 Res.mul
+   abs    = notImplemented "abs"
+   signum = notImplemented "signum"
+
 instance Eq (T a) where
-   (==) = error "ResidueClass.Func: (==) not implemented"
+   (==) = notImplemented "(==)"
 
 instance Show (T a) where
-   show = error "ResidueClass.Func: 'show' not implemented"
+   show = notImplemented "show"
diff --git a/src/Number/SI.hs b/src/Number/SI.hs
--- a/src/Number/SI.hs
+++ b/src/Number/SI.hs
@@ -1,8 +1,9 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {- |
-Copyright   :  (c) Henning Thielemann 2003-2006
+Copyright   :  (c) Henning Thielemann 2003-2012
 License     :  GPL
 
 Maintainer  :  numericprelude@henning-thielemann.de
@@ -40,6 +41,8 @@
 
 import Data.Tuple.HT (mapFst, )
 
+import qualified MathObj.Wrapper.Haskell98 as W98
+
 import qualified Prelude as P
 
 import NumericPrelude.Numeric
@@ -47,9 +50,7 @@
 
 
 newtype T a v = Cons (PValue v)
-{- LANGUAGE GeneralizedNewtypeDeriving allows even this
-   deriving (Monad, Functor)
--}
+   deriving (Functor)
 
 type PValue v = Value.T Dimension v
 
@@ -249,21 +250,14 @@
 
 
 
--- legacy instances for work with GHCi
-legacyInstance :: a
-legacyInstance =
-   error "legacy Ring.C instance for simple input of numeric literals"
-
-instance (Ord a, Trans.C a, NormedMax.C a v, P.Num v, Ring.C v) =>
-      P.Num (T a v) where
-   fromInteger = fromInteger
-   negate = negate -- for unary minus
-   (+)    = legacyInstance
-   (*)    = legacyInstance
-   abs    = legacyInstance
-   signum = legacyInstance
+instance (P.Num v) => P.Num (T a v) where
+   fromInteger = fromScalarSingle . P.fromInteger
+   negate = W98.unliftF1 Additive.negate
+   (+)    = W98.unliftF2 (Additive.+)
+   (*)    = W98.unliftF2 (Ring.*)
+   abs    = W98.unliftF1 Absolute.abs
+   signum = W98.unliftF1 Absolute.signum
 
-instance (Ord a, Trans.C a, NormedMax.C a v, P.Num v, Field.C v) =>
-      P.Fractional (T a v) where
-   fromRational = fromRational
-   (/) = legacyInstance
+instance (P.Fractional v) => P.Fractional (T a v) where
+   fromRational = fromScalarSingle . P.fromRational
+   (/) = W98.unliftF2 (Field./)
diff --git a/test/Test.hs b/test/Test.hs
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -10,6 +10,8 @@
            deca, hecto, kilo, mega, giga, tera, peta)
 import Number.OccasionallyScalarExpression as Expr
 
+import qualified Number.NonNegativeChunky as Chunky
+import qualified Number.NonNegative       as NonNegW
 import qualified Number.Positional.Check  as Absolute
 import qualified Number.FixedPoint.Check  as FixedPoint
 import qualified Number.ResidueClass.Func as ResidueClass
@@ -167,6 +169,9 @@
 testPeanoList :: [Char]
 testPeanoList =
    genericTake (genericLength (repeat 'a') :: Peano.T) ['a'..'z']
+
+testChunky :: Chunky.T NonNegW.Int
+testChunky = (2+3)*(1+5)
 
 
 main :: IO ()
diff --git a/test/Test/MathObj/Matrix.hs b/test/Test/MathObj/Matrix.hs
--- a/test/Test/MathObj/Matrix.hs
+++ b/test/Test/MathObj/Matrix.hs
@@ -9,14 +9,13 @@
 
 import qualified Algebra.Laws as Laws
 
-import qualified Number.NonNegative as NonNeg
-
 import qualified System.Random as Random
 
 import Data.Function.HT (nest, )
 
 import Test.NumericPrelude.Utility (testUnit, )
-import Test.QuickCheck (quickCheck, )
+import Test.QuickCheck (Arbitrary(arbitrary), quickCheck, )
+import qualified Test.QuickCheck as QC
 import qualified Test.HUnit as HUnit
 
 
@@ -25,12 +24,17 @@
 
 
 type Seed = Int
-type Dimension = NonNeg.Int
+newtype Dimension = Dimension {unDim :: Int}
+   deriving (Show)
 
+instance Arbitrary Dimension where
+   arbitrary = fmap Dimension $ QC.choose (0,20)
+
+
 random :: Dimension -> Dimension -> Seed -> Matrix.T Integer
 random mn nn seed =
    fst $
-   Matrix.random (NonNeg.toNumber mn) (NonNeg.toNumber nn) $
+   Matrix.random (unDim mn) (unDim nn) $
    Random.mkStdGen seed
 
 
@@ -41,15 +45,15 @@
    map testUnit $
       ("dimension",
           quickCheck (\m n a ->
-             (NonNeg.toNumber m, NonNeg.toNumber n) == Matrix.dimension (random m n a))) :
+             (unDim m, unDim n) == Matrix.dimension (random m n a))) :
       ("to and from rows",
           quickCheck (\m n a' ->
              let a = random m n a'
-             in  a == Matrix.fromRows (NonNeg.toNumber m) (NonNeg.toNumber n) (Matrix.rows a))) :
+             in  a == Matrix.fromRows (unDim m) (unDim n) (Matrix.rows a))) :
       ("to and from columns",
           quickCheck (\m n a' ->
              let a = random m n a'
-             in  a == Matrix.fromColumns (NonNeg.toNumber m) (NonNeg.toNumber n) (Matrix.columns a))) :
+             in  a == Matrix.fromColumns (unDim m) (unDim n) (Matrix.columns a))) :
       ("transpose, rows, columns",
           quickCheck (\m n a' ->
              let a = random m n a'
@@ -60,7 +64,7 @@
              in  Matrix.columns a == Matrix.rows (Matrix.transpose a))) :
       ("addition, zero",
           quickCheck (\m n a ->
-             Laws.identity (+) (Matrix.zero (NonNeg.toNumber m) (NonNeg.toNumber n)) (random m n a))) :
+             Laws.identity (+) (Matrix.zero (unDim m) (unDim n)) (random m n a))) :
       ("addition, commutative",
           quickCheck (\m n a b ->
              Laws.commutative (+) (random m n a) (random m n b))) :
@@ -72,14 +76,14 @@
              Laws.homomorphism Matrix.transpose (+) (+) (random m n a) (random m n b))) :
       ("one, diagonal",
           quickCheck (\n' ->
-             let n = NonNeg.toNumber n'
+             let n = unDim n'
              in Matrix.one n == (Matrix.diagonal $ replicate n Ring.one :: Matrix.T Integer))) :
       ("multiplication, one left",
           quickCheck (\m n a ->
-             Laws.leftIdentity  (*) (Matrix.one (NonNeg.toNumber m)) (random m n a))) :
+             Laws.leftIdentity  (*) (Matrix.one (unDim m)) (random m n a))) :
       ("multiplication, one right",
           quickCheck (\m n a ->
-             Laws.rightIdentity (*) (Matrix.one (NonNeg.toNumber n)) (random m n a))) :
+             Laws.rightIdentity (*) (Matrix.one (unDim n)) (random m n a))) :
       ("multiplication, associative",
           quickCheck (\k l m n a b c ->
              Laws.associative (*) (random k l a) (random l m b) (random m n c))) :
@@ -96,7 +100,7 @@
           quickCheck (\m a n0 ->
              let x = random m m a
                  n = mod n0 10
-             in  x^n == nest (fromInteger n) (x*) (Matrix.one (NonNeg.toNumber m)))) :
+             in  x^n == nest (fromInteger n) (x*) (Matrix.one (unDim m)))) :
 {-
       ("division",       quickCheck (\x -> Integral.propInverse (x :: Poly.T Rational))) :
 -}