typo fix for Euclidean

Author: njericha

README.md

@@ -95,7 +95,7 @@ mtt(A, G) == Z # matrix times tensor
 
 The output variable `stats` is a `DataFrame` that records the requested stats every iteration. You can pass a list of supported stats, or custom stats. See [`Iteration Stats`](@ref) for more details.
 
-By default, the iteration number, objective value (L2 norm between the input and the model in this case), and the Euclidian norm of the gradient (of the loss function at the current iteration) are recorded. The following would reproduce the default stats in our running example.
+By default, the iteration number, objective value (L2 norm between the input and the model in this case), and the Euclidean norm of the gradient (of the loss function at the current iteration) are recorded. The following would reproduce the default stats in our running example.
 
 ```julia
 X, stats, kwargs = factorize(Y;

docs/src/index.md

@@ -5,7 +5,7 @@
 
 (Coming Soon) The package also supports user defined models and constraints provided the operations for combining factor into a tensor, and projecting/applying the constraint are given. It is also a longer term goal to support other optimization objective beyond minimizing the least-squares (Frobenius norm) between the input tensor and model.
 
-The general scheme for computing the decomposition is a generalization of Xu and Yin's Block Coordinate Descent Method (2013) that cyclicaly updates each factor in a model with a proximal gradient descent step. Note for convex constraints, the proximal operation would be a Euclidian projection onto the constraint set, but we find some improvment with a hybrid approach of a partial Euclidian projection followed by a rescaling step. In the case of a simplex constraint on one factor, this looks like: dividing the constrained factor by the sum of entries, and multiplying another factor by this sum to preserve the product.
+The general scheme for computing the decomposition is a generalization of Xu and Yin's Block Coordinate Descent Method (2013) that cyclicaly updates each factor in a model with a proximal gradient descent step. Note for convex constraints, the proximal operation would be a Euclidean projection onto the constraint set, but we find some improvment with a hybrid approach of a partial Euclidean projection followed by a rescaling step. In the case of a simplex constraint on one factor, this looks like: dividing the constrained factor by the sum of entries, and multiplying another factor by this sum to preserve the product.
 
 
 ```@contents

docs/src/quickguide.md

@@ -66,7 +66,7 @@ mtt(A, G) == Z # matrix times tensor
 
 The output variable `stats` is a `DataFrame` that records the requested stats every iteration. You can pass a list of supported stats, or custom stats. See [Iteration Stats](@ref) for more details.
 
-By default, the iteration number, objective value (L2 norm between the input and the model in this case), and the Euclidian norm of the gradient (of the loss function at the current iteration) are recorded. The following would reproduce the default stats in our running example.
+By default, the iteration number, objective value (L2 norm between the input and the model in this case), and the Euclidean norm of the gradient (of the loss function at the current iteration) are recorded. The following would reproduce the default stats in our running example.
 
 ```julia
 X, stats, kwargs = factorize(Y;

docs/src/tutorial/iterationstats.md

@@ -15,8 +15,8 @@ ObjectiveRatio
 RelativeError
 IterateNormDiff
 IterateRelativeDiff
-EuclidianStepSize
-EuclidianLipschitz
+EuclideanStepSize
+EuclideanLipschitz
 FactorNorms
 PrintStats
 DisplayDecomposition
@@ -33,8 +33,8 @@ ObjectiveRatio
 RelativeError
 IterateNormDiff
 IterateRelativeDiff
-EuclidianStepSize
-EuclidianLipschitz
+EuclideanStepSize
+EuclideanLipschitz
 FactorNorms
 ```
 

example/constrainedCP.jl

@@ -28,7 +28,7 @@ options = (
     momentum=true,
     final_constraints = l1scale_cols!,
     stats=[
-        Iteration, ObjectiveValue, GradientNNCone, RelativeError, FactorNorms, EuclidianLipschitz
+        Iteration, ObjectiveValue, GradientNNCone, RelativeError, FactorNorms, EuclideanLipschitz
     ],
 )
 

example/constrainedTucker.jl

@@ -17,7 +17,7 @@ decomposition, stats_data, kwargs = fact(Y;
     converged=(GradientNNCone, RelativeError),
     constrain_init=true,
     constraints=nonnegative!,
-    stats=[Iteration, ObjectiveValue, GradientNNCone, RelativeError, EuclidianLipschitz, EuclidianStepSize]
+    stats=[Iteration, ObjectiveValue, GradientNNCone, RelativeError, EuclideanLipschitz, EuclideanStepSize]
 );
 
 display(stats_data)
@@ -27,4 +27,4 @@ display(kwargs[:update])
 # using Pkg
 # Pkg.add("Plots")
 # using Plots
-# plot(stats_data[2:end, :EuclidianLipschitz], stats_data[2:end, :EuclidianStepSize])
+# plot(stats_data[2:end, :EuclideanLipschitz], stats_data[2:end, :EuclideanStepSize])

example/constrainedTucker1.jl

@@ -14,7 +14,7 @@ decomposition, stats_data, kwargs = fact(Y;
     converged=(GradientNNCone, RelativeError),
     constrain_init=true,
     constraints=nonnegative!,
-    stats=[Iteration, ObjectiveValue, GradientNNCone, RelativeError, EuclidianLipschitz, EuclidianStepSize]
+    stats=[Iteration, ObjectiveValue, GradientNNCone, RelativeError, EuclideanLipschitz, EuclideanStepSize]
 );
 
 display(stats_data)
@@ -24,4 +24,4 @@ display(kwargs[:update])
 # using Pkg
 # Pkg.add("Plots")
 # using Plots
-# plot(stats_data[2:end, :EuclidianLipschitz], stats_data[2:end, :EuclidianStepSize])
+# plot(stats_data[2:end, :EuclideanLipschitz], stats_data[2:end, :EuclideanStepSize])

src/BlockTensorFactorization.jl

@@ -62,7 +62,7 @@ export LinearConstraint
 
 #include("./stats.jl")
 export AbstractStat
-export DisplayDecomposition, EuclidianLipschitz, EuclidianStepSize, FactorNorms, GradientNorm, GradientNNCone
+export DisplayDecomposition, EuclideanLipschitz, EuclideanStepSize, FactorNorms, GradientNorm, GradientNNCone
 export IterateNormDiff, IterateRelativeDiff, Iteration, ObjectiveValue, ObjectiveRatio, PrintStats, RelativeError
 
 #include("./blockupdates.jl")

src/Core/Core.jl

@@ -72,7 +72,7 @@ export LinearConstraint
 
 include("./stats.jl")
 export AbstractStat
-export DisplayDecomposition, EuclidianLipschitz, EuclidianStepSize, FactorNorms, GradientNorm, GradientNNCone
+export DisplayDecomposition, EuclideanLipschitz, EuclideanStepSize, FactorNorms, GradientNorm, GradientNNCone
 export IterateNormDiff, IterateRelativeDiff, Iteration, ObjectiveValue, ObjectiveRatio, PrintStats, RelativeError
 
 include("./blockupdates.jl")

src/Core/stats.jl

@@ -133,30 +133,30 @@ The 2-norm of the stepsizes that would be taken for all blocks.
 For example, if there are two blocks, and we would take a stepsize of A to update one block
 and B to update the other, this would return sqrt(A^2 + B^2).
 """
-struct EuclidianStepSize{T} <: AbstractStat
+struct EuclideanStepSize{T} <: AbstractStat
     steps::T
-    function EuclidianStepSize{T}(steps) where T
+    function EuclideanStepSize{T}(steps) where T
         @assert all(x -> typeof(x) <: AbstractStep, steps)
         new{T}(steps)
     end
 end
 
-EuclidianStepSize(; steps, kwargs...) = EuclidianStepSize{typeof(steps)}(steps)
+EuclideanStepSize(; steps, kwargs...) = EuclideanStepSize{typeof(steps)}(steps)
 
 """
 The 2-norm of the lipschitz constants that would be taken for all blocks.
 
-Need the stepsizes to be lipschitz steps since it is calculated similarly to EuclidianStepSize.
+Need the stepsizes to be lipschitz steps since it is calculated similarly to EuclideanStepSize.
 """
-struct EuclidianLipschitz{T} <: AbstractStat
+struct EuclideanLipschitz{T} <: AbstractStat
     steps::T
-    function EuclidianLipschitz{T}(steps) where T
+    function EuclideanLipschitz{T}(steps) where T
         @assert all(x -> typeof(x) <: AbstractStep, steps)
         new{T}(steps)
     end
 end
 
-EuclidianLipschitz(; steps, kwargs...) = EuclidianLipschitz{typeof(steps)}(steps)
+EuclideanLipschitz(; steps, kwargs...) = EuclideanLipschitz{typeof(steps)}(steps)
 
 """
     FactorNorms(; norm, kwargs...)
@@ -189,8 +189,8 @@ end
 
 (S::IterateNormDiff)(X, _, previous, _, _) = S.norm(X - previous[begin])
 (S::IterateRelativeDiff)(X, _, previous, _, _) = S.norm(X - previous[begin]) / S.norm(previous[begin])
-(S::EuclidianStepSize)(X, _, _, _, _) = sqrt.(sum(calcstep -> calcstep(X)^2, S.steps))
-(S::EuclidianLipschitz)(X, _, _, _, _) = sqrt.(sum(calcstep -> calcstep(X)^(-2), S.steps))
+(S::EuclideanStepSize)(X, _, _, _, _) = sqrt.(sum(calcstep -> calcstep(X)^2, S.steps))
+(S::EuclideanLipschitz)(X, _, _, _, _) = sqrt.(sum(calcstep -> calcstep(X)^(-2), S.steps))
 (S::FactorNorms)(X, _, _, _, _) = S.norm.(factors(X))
 (S::PrintStats)(_, _, _, parameters, stats) = if parameters[:iteration] > 0; println(last(stats)); end
 function (S::DisplayDecomposition)(X, _, _, parameters, _)