diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # accelerate-kullback-liebler
 
+## 0.1.2.0
+
+  * Add `f`-divergence, `alpha`-divergence, Hellinger distance
+
 ## 0.1.1.0
 
   * Add `scale` function
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
 # accelerate-kullback-liebler
 
-Kullback-Liebler divergence on arrays.
+Kullback-Liebler divergence, Hellinger distance, alpha-divergence, and
+f-divergence on arrays.
diff --git a/accelerate-kullback-liebler.cabal b/accelerate-kullback-liebler.cabal
--- a/accelerate-kullback-liebler.cabal
+++ b/accelerate-kullback-liebler.cabal
@@ -1,6 +1,6 @@
 cabal-version:   2.0
 name:            accelerate-kullback-liebler
-version:         0.1.1.0
+version:         0.1.2.0
 license:         BSD3
 license-file:    LICENSE
 copyright:       Copyright: (c) 2019-2020 Vanessa McHale
diff --git a/bench/Bench.cpphs b/bench/Bench.cpphs
--- a/bench/Bench.cpphs
+++ b/bench/Bench.cpphs
@@ -26,13 +26,17 @@
                   bgroup "GPU"
                       [ bench "K-L (1e7)" $ nf (kullbackLieblerGPU ps) qs
                       , bench "entropy (1e7)" $ nf entropyGPU ps
+                      , bench "K-L (1e7) (scaled)" $ nf (kullbackLieblerGPUScaled ps) qs
+                      , bench "entropy (1e7) (scaled)" $ nf entropyGPUScaled ps
                       ]
                 , bgroup "CPU"
 #else
                   bgroup "CPU"
 #endif
                       [ bench "K-L (1e7)" $ nf (kullbackLieblerCPU ps) qs
+                      , bench "K-L (1e7) (scaled)" $ nf (kullbackLieblerCPUScaled ps) qs
                       , bench "entropy (1e7)" $ nf entropyCPU ps
+                      , bench "entropy (1e7) (scaled)" $ nf entropyCPUScaled ps
                       ]
                 ]
 
@@ -40,8 +44,12 @@
           distEnv = randDist (A.Z A.:. 10000000)
 #ifdef ACCELERATE_GPU
           kullbackLieblerGPU ps qs = the $ GPU.run $ kullbackLiebler ps qs
+          kullbackLieblerGPUScaled ps qs = the $ GPU.run $ kullbackLiebler (scale ps) (scale qs)
           entropyGPU = the . GPU.run . entropy
+          entropyGPUScaled = the . GPU.run . entropy . scale
 #endif
           -- TODO: runQ
           kullbackLieblerCPU ps qs = the $ CPU.run $ kullbackLiebler ps qs
+          kullbackLieblerCPUScaled ps qs = the $ CPU.run $ kullbackLiebler (scale ps) (scale qs)
           entropyCPU = the . CPU.run . entropy
+          entropyCPUScaled = the . CPU.run . entropy . scale
diff --git a/src/Data/Array/Accelerate/KullbackLiebler.hs b/src/Data/Array/Accelerate/KullbackLiebler.hs
--- a/src/Data/Array/Accelerate/KullbackLiebler.hs
+++ b/src/Data/Array/Accelerate/KullbackLiebler.hs
@@ -5,9 +5,35 @@
                                              , entropy
                                              , dropZeroes
                                              , scale
+                                             , hellinger
+                                             , fDivergence
+                                             , alphaDivergence
                                              ) where
 
 import qualified Data.Array.Accelerate as A
+
+-- | \( D_f(p \| q) = \displaystyle\int p(x) f\left(\frac{p(x)}{q(x)}\right) dx \)
+--
+-- @since 0.1.2.0
+fDivergence :: (A.Floating e) => (A.Exp e -> A.Exp e) -- ^ \(f\)
+            -> A.Acc (A.Vector e)
+            -> A.Acc (A.Vector e)
+            -> A.Acc (A.Scalar e)
+fDivergence f ps qs = A.sum (A.zipWith (\p q -> p * f (p / q)) ps qs)
+
+-- | \( D^{(\alpha)}(p\| q) = \frac{4}{1 - \alpha^2}\left(1 - \displaystyle\int p(x)^{\frac{1-\alpha}{2}} q(x)^{\frac{1+\alpha}{2}} dx\right)\)
+-- for \( \alpha \neq \pm 1\)
+--
+-- @since 0.1.2.0
+alphaDivergence :: A.Floating e => A.Exp e -> A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)
+alphaDivergence α ps qs = A.map (\x -> (4 / (1 - α ** 2)) * (1 - x)) integrand
+    where integrand = A.sum (A.zipWith (\p q -> p ** ((1 - α)/2) * q ** ((1 + α)/2)) ps qs)
+
+-- | Hellinger distance
+--
+-- @since 0.1.2.0
+hellinger :: (A.Floating e) => A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)
+hellinger ps qs = A.map (A.sqrt . (2*)) $ A.sum (A.zipWith (\p q -> (A.sqrt p - A.sqrt q) ** 2) ps qs)
 
 -- | Assumes input is nonzero
 kullbackLiebler :: (A.Floating e) => A.Acc (A.Vector e) -> A.Acc (A.Vector e) -> A.Acc (A.Scalar e)
diff --git a/test/Spec.cpphs b/test/Spec.cpphs
--- a/test/Spec.cpphs
+++ b/test/Spec.cpphs
@@ -5,7 +5,7 @@
 
 import           Control.Composition                   ((.$))
 import qualified Data.Array.Accelerate                 as A
-import           Data.Array.Accelerate.KullbackLiebler (kullbackLiebler, scale)
+import           Data.Array.Accelerate.KullbackLiebler (hellinger, kullbackLiebler, scale)
 import qualified Data.Array.Accelerate.LLVM.Native     as CPU
 #ifdef ACCELERATE_GPU
 import qualified Data.Array.Accelerate.LLVM.PTX        as GPU
@@ -30,18 +30,24 @@
         assertBool "simple unit test" =<< selfCPU
     ]
 
---TODO: random gen/normalization?
 commonData :: IO (A.Acc (A.Scalar Double))
 commonData = do
     datums <- randDist (A.Z A.:. 1000000)
-    pure $ kullbackLiebler .$ (scale datums)
+    pure $ kullbackLiebler .$ scale datums
 
+hellingerData :: IO (A.Acc (A.Scalar Double))
+hellingerData = do
+    datums <- randDist (A.Z A.:. 1000000)
+    pure $ hellinger .$ scale datums
+
 #ifdef ACCELERATE_GPU
 selfGPU :: IO Bool
 selfGPU = do
     datums <- commonData
+    datums' <- hellingerData
     let res = the $ GPU.run datums
-    pure $ res == 0
+        res' = the $ GPU.run datums'
+    pure $ res == 0 && res' == 0
 #endif
 
 selfCPU :: IO Bool