Delete trailing whitespace (#234)

modified:   src/Distances.jl
	modified:   src/bregman.jl

Author: jlapeyre

src/Distances.jl

@@ -102,8 +102,8 @@ export
 
 if VERSION < v"1.2-"
     import Base: has_offset_axes
-    require_one_based_indexing(A...) = 
-        !has_offset_axes(A...) || 
+    require_one_based_indexing(A...) =
+        !has_offset_axes(A...) ||
             throw(ArgumentError("offset arrays are not supported but got an array with index other than 1"))
 else
     import Base: require_one_based_indexing

src/bregman.jl

@@ -1,14 +1,14 @@
-# Bregman divergence 
+# Bregman divergence
 
 """
 Implements the Bregman divergence, a friendly introduction to which can be found
-[here](http://mark.reid.name/blog/meet-the-bregman-divergences.html). 
-Bregman divergences are a minimal implementation of the "mean-minimizer" property. 
+[here](http://mark.reid.name/blog/meet-the-bregman-divergences.html).
+Bregman divergences are a minimal implementation of the "mean-minimizer" property.
 
-It is assumed that the (convex differentiable) function F maps vectors (of any type or size) to real numbers. 
-The inner product used is `Base.dot`, but one can be passed in either by defining `inner` or by 
-passing in a keyword argument. If an analytic gradient isn't available, Julia offers a suite 
-of good automatic differentiation packages. 
+It is assumed that the (convex differentiable) function F maps vectors (of any type or size) to real numbers.
+The inner product used is `Base.dot`, but one can be passed in either by defining `inner` or by
+passing in a keyword argument. If an analytic gradient isn't available, Julia offers a suite
+of good automatic differentiation packages.
 
 function evaluate(dist::Bregman, p::AbstractVector, q::AbstractVector)
 """
@@ -18,31 +18,31 @@ struct Bregman{T1 <: Function, T2 <: Function, T3 <: Function} <: PreMetric
     inner::T3
 end
 
-# Default costructor. 
+# Default costructor.
 Bregman(F, ∇) =  Bregman(F, ∇, LinearAlgebra.dot)
 
-# Evaluation fuction 
+# Evaluation fuction
 function (dist::Bregman)(p, q)
     # Create cache vals.
     FP_val = dist.F(p)
-    FQ_val = dist.F(q) 
+    FQ_val = dist.F(q)
     DQ_val = dist.∇(q)
     p_size = length(p)
-    # Check F codomain. 
+    # Check F codomain.
     if !(isa(FP_val, Real) && isa(FQ_val, Real))
         throw(ArgumentError("F Codomain Error: F doesn't map the vectors to real numbers"))
-    end 
-    # Check vector size. 
+    end
+    # Check vector size.
     if p_size != length(q)
         throw(DimensionMismatch("The vector p ($(size(p))) and q ($(size(q))) are different sizes."))
     end
-    # Check gradient size. 
+    # Check gradient size.
     if length(DQ_val) != p_size
         throw(DimensionMismatch("The gradient result is not the same size as p and q"))
-    end 
-    # Return the Bregman divergence. 
+    end
+    # Return the Bregman divergence.
     return FP_val - FQ_val - dist.inner(DQ_val, p .- q)
-end 
+end
 
-# Convenience function. 
+# Convenience function.
 bregman(F, ∇, x, y; inner = LinearAlgebra.dot) = Bregman(F, ∇, inner)(x, y)