diff --git a/CHANGES b/CHANGES
--- a/CHANGES
+++ b/CHANGES
@@ -51,3 +51,9 @@
 
 0.1.3:
 		Add Float versions of some functions
+
+0.1.3.1:
+		change base to >= 4
+
+0.1.3.2:
+		remove unicode symbols
diff --git a/hsignal.cabal b/hsignal.cabal
--- a/hsignal.cabal
+++ b/hsignal.cabal
@@ -1,5 +1,5 @@
 Name:               hsignal
-Version:            0.1.3
+Version:            0.1.3.2
 License:            BSD3
 License-file:       LICENSE
 Author:             Vivian McPhail
@@ -32,11 +32,10 @@
 
 library
 
-    Build-Depends:      base >= 3 && < 5,
+    Build-Depends:      base >= 4 && < 5,
                         mtl, 
                         array,
                         bytestring, storable-complex, binary,
-                        base-unicode-symbols,
                         hmatrix >= 0.10.0.0,
                         hmatrix-gsl-stats >= 0.1.2.6,
                         hstatistics >= 0.2.2.5
diff --git a/lib/Numeric/Signal.hs b/lib/Numeric/Signal.hs
--- a/lib/Numeric/Signal.hs
+++ b/lib/Numeric/Signal.hs
@@ -1,6 +1,5 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE UnicodeSyntax #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Numeric.Signal
@@ -59,7 +58,7 @@
 
 -- | filters the signal
 filter :: (S.Filterable a) 
-         ⇒ Vector a   -- ^ zero coefficients
+         => Vector a   -- ^ zero coefficients
        -> Vector a     -- ^ pole coefficients
        -> Int   -- ^ sampling rate
        -> Vector a     -- ^ input signal
@@ -89,7 +88,7 @@
 -----------------------------------------------------------------------------
 
 -- | a broadband FIR
-broadband_fir :: (S.Filterable a, Double ~ DoubleOf a, Container Vector (Complex a), Convert (Complex a))  ⇒
+broadband_fir :: (S.Filterable a, Double ~ DoubleOf a, Container Vector (Complex a), Convert (Complex a)) =>
                 Int           -- ^ sampling rate
               -> (Int,Int)     -- ^ (lower,upper) frequency cutoff
               -> Vector a -- ^ filter coefficients   
@@ -104,7 +103,7 @@
 
 -- | a broadband filter
 broadband_filter :: (S.Filterable a, Double ~ DoubleOf a, Container Vector (Complex a), Convert (Complex a)) 
-                   ⇒ Int        -- ^ sampling rate
+                   => Int        -- ^ sampling rate
                  -> (Int,Int)    -- ^ (lower,upper) frequency cutoff
                  -> Vector a            -- ^ input signal
                  -> Vector a            -- ^ output signal
@@ -115,7 +114,7 @@
 
 -- | standard FIR filter
 -- |   FIR filter with grid a power of 2 greater than the order, ramp = grid/16, hamming window
-standard_fir :: (S.Filterable a, Double ~ DoubleOf a, Container Vector (Complex a), Convert (Complex a)) ⇒ 
+standard_fir :: (S.Filterable a, Double ~ DoubleOf a, Container Vector (Complex a), Convert (Complex a)) => 
                Int -> [(a,a)] -> Vector a
 standard_fir o be = let grid  = calc_grid o
                         trans = grid `div` 16
@@ -128,7 +127,7 @@
 
 -- | produce an FIR filter
 fir :: (S.Filterable a
-      , Container Vector (Complex a), Convert (Complex a), Double ~ DoubleOf a) ⇒
+      , Container Vector (Complex a), Convert (Complex a), Double ~ DoubleOf a) =>
       Int               -- ^ order (one less than the length of the filter)
     -> [(a,a)] -- ^ band edge frequency, nondecreasing, [0, f1, ..., f(n-1), 1]
                         -- ^ band edge magnitude
@@ -154,24 +153,24 @@
     | x > 1.0   = 1.0
     | otherwise = x
 
-diff :: S.Filterable a ⇒ a -> [a] -> [a]
+diff :: S.Filterable a => a -> [a] -> [a]
 diff _ []  = []
 diff _ [x] = [x]
 diff inc (x1:x2:xs)
      | x1 == x2     = (floor_zero $ x1-inc):x1:(ceil_one $ x1+inc):(diff inc (L.filter (/= x2) xs))
      | otherwise    = x1:(diff inc (x2:xs))
 
-interpolate :: S.Filterable a ⇒ [a] -> [a] -> [a] -> [a]
+interpolate :: S.Filterable a => [a] -> [a] -> [a] -> [a]
 interpolate _ _ []      = []
 interpolate x y (xp:xs) = if xp == 1.0 
                              then ((interpolate'' ((length x)-1) x y xp):(interpolate x y xs))
                              else ((interpolate' x y xp):(interpolate x y xs))
 
-interpolate' :: S.Filterable a ⇒ [a] -> [a] -> a -> a
+interpolate' :: S.Filterable a => [a] -> [a] -> a -> a
 interpolate' x y xp = let Just j = L.findIndex (> xp) x
                       in (interpolate'' j x y xp)
 
-interpolate'' :: S.Filterable a ⇒ Int -> [a] -> [a] -> a -> a
+interpolate'' :: S.Filterable a => Int -> [a] -> [a] -> a -> a
 interpolate'' j x y xp = let x0 = x !! (j-1)
                              y0 = y !! (j-1)
                              x1 = x !! j
@@ -181,7 +180,7 @@
 -----------------------------------------------------------------------------
 
 -- | determine the frequency response of a filter, given a vector of frequencies
-freqzF :: (S.Filterable a, Double ~ DoubleOf a, S.Filterable (DoubleOf a)) ⇒ 
+freqzF :: (S.Filterable a, Double ~ DoubleOf a, S.Filterable (DoubleOf a)) => 
          Vector a     -- ^ zero coefficients
        -> Vector a       -- ^ pole coefficients
        -> Int     -- ^ sampling rate   
@@ -190,7 +189,7 @@
 freqzF b a s f = S.freqz b a ((2*pi/(fromIntegral s)) * f)
 
 -- | determine the frequency response of a filter, given a number of points and sampling rate
-freqzN :: (S.Filterable a, Enum a, Double ~ DoubleOf a) ⇒ 
+freqzN :: (S.Filterable a, Enum a, Double ~ DoubleOf a) =>
          Vector a     -- ^ zero coefficients
        -> Vector a       -- ^ pole coefficients
        -> Int     -- ^ sampling rate
@@ -207,12 +206,12 @@
 analytic_signal = S.hilbert
 
 -- | the power (amplitude^2 = v * (conj c)) of an analytic signal
-analytic_power :: S.Filterable a ⇒ Vector (Complex Double) -> Vector a
+analytic_power :: S.Filterable a => Vector (Complex Double) -> Vector a
 analytic_power = S.complex_power_
 
 -- | the phase of an analytic signal
 analytic_phase :: (S.Filterable a, Container Vector a
-                 ,Double ~ DoubleOf a) ⇒ 
+                 ,Double ~ DoubleOf a) => 
                  Vector (Complex a) -> Vector a
 analytic_phase = (uncurry arctan2) . fromComplex
 
@@ -237,27 +236,27 @@
 -----------------------------------------------------------------------------
 
 -- | resize the vector to length n by resampling
-resize :: S.Filterable a ⇒ Int -> Vector a -> Vector a
+resize :: S.Filterable a => Int -> Vector a -> Vector a
 resize n v = S.downsample_ (dim v `div` n) v
 
 -----------------------------------------------------------------------------
 
 -- | coefficients of a Hamming window
-hamming :: S.Filterable a ⇒
+hamming :: S.Filterable a =>
           Int           -- ^ length
         -> Vector a -- ^ the Hamming coeffficents
 hamming = S.hamming_
 
 -- | resample, take one sample every n samples in the original
-downsample :: S.Filterable a ⇒ Int -> Vector a -> Vector a
+downsample :: S.Filterable a => Int -> Vector a -> Vector a
 downsample = S.downsample_
 
 -- | the difference between consecutive elements of a vector
-deriv :: S.Filterable a ⇒ Vector a -> Vector a
+deriv :: S.Filterable a => Vector a -> Vector a
 deriv = S.deriv_
 
 -- | unwrap the phase of signal (input expected to be within (-pi,pi)
-unwrap :: S.Filterable a ⇒ Vector a -> Vector a
+unwrap :: S.Filterable a => Vector a -> Vector a
 unwrap = S.unwrap_
 
 -----------------------------------------------------------------------------