Merge pull request #165 from JuliaML/auto-juliaformatter-pr

[AUTO] JuliaFormatter.jl run

Author: juliohm

docs/make.jl

@@ -3,42 +3,25 @@ using Documenter, LossFunctions
 DocMeta.setdocmeta!(LossFunctions, :DocTestSetup, :(using LossFunctions); recursive=true)
 
 makedocs(
-    modules=[LossFunctions],
-    authors="Christof Stocker, Tom Breloff, Alex Williams",
-    repo="https://github.com/JuliaML/LossFunctions.jl/blob/{commit}{path}#{line}",
-    sitename="LossFunctions.jl",
-    format=Documenter.HTML(
-        prettyurls=get(ENV, "CI", "false") == "true",
-        canonical="https://JuliaML.github.io/LossFunctions.jl",
-        assets=["assets/style.css", "assets/favicon.ico"]
-    ),
-    pages=[
-        hide("Home" => "index.md"),
-        "Introduction" => [
-            "introduction/gettingstarted.md",
-            "introduction/motivation.md",
-        ],
-        "User's Guide" => [
-            "user/interface.md",
-            "user/aggregate.md",
-        ],
-        "Available Losses" => [
-            "losses/distance.md",
-            "losses/margin.md",
-            "losses/other.md",
-        ],
-        "Advances Topics" => [
-            "advanced/extend.md",
-            "advanced/developer.md",
-        ],
-        hide("Indices" => "indices.md"),
-        "acknowledgements.md",
-        "LICENSE.md",
-    ]
+  modules=[LossFunctions],
+  authors="Christof Stocker, Tom Breloff, Alex Williams",
+  repo="https://github.com/JuliaML/LossFunctions.jl/blob/{commit}{path}#{line}",
+  sitename="LossFunctions.jl",
+  format=Documenter.HTML(
+    prettyurls=get(ENV, "CI", "false") == "true",
+    canonical="https://JuliaML.github.io/LossFunctions.jl",
+    assets=["assets/style.css", "assets/favicon.ico"]
+  ),
+  pages=[
+    hide("Home" => "index.md"),
+    "Introduction" => ["introduction/gettingstarted.md", "introduction/motivation.md"],
+    "User's Guide" => ["user/interface.md", "user/aggregate.md"],
+    "Available Losses" => ["losses/distance.md", "losses/margin.md", "losses/other.md"],
+    "Advances Topics" => ["advanced/extend.md", "advanced/developer.md"],
+    hide("Indices" => "indices.md"),
+    "acknowledgements.md",
+    "LICENSE.md"
+  ]
 )
 
-deploydocs(
-    repo="github.com/JuliaML/LossFunctions.jl.git",
-    devbranch="master",
-    push_preview=true
-)
+deploydocs(repo="github.com/JuliaML/LossFunctions.jl.git", devbranch="master", push_preview=true)

src/LossFunctions.jl

@@ -16,58 +16,67 @@ include("losses.jl")
 include("io.jl")
 
 export
-    # trait functions
-    Loss,
-    SupervisedLoss,
-    MarginLoss,
-    DistanceLoss,
-    deriv, deriv2,
-    isdistancebased, ismarginbased,
-    isminimizable, isdifferentiable,
-    istwicedifferentiable,
-    isconvex, isstrictlyconvex,
-    isstronglyconvex, isnemitski,
-    isunivfishercons, isfishercons,
-    islipschitzcont, islocallylipschitzcont,
-    isclipable, isclasscalibrated, issymmetric,
+  # trait functions
+  Loss,
+  SupervisedLoss,
+  MarginLoss,
+  DistanceLoss,
+  deriv,
+  deriv2,
+  isdistancebased,
+  ismarginbased,
+  isminimizable,
+  isdifferentiable,
+  istwicedifferentiable,
+  isconvex,
+  isstrictlyconvex,
+  isstronglyconvex,
+  isnemitski,
+  isunivfishercons,
+  isfishercons,
+  islipschitzcont,
+  islocallylipschitzcont,
+  isclipable,
+  isclasscalibrated,
+  issymmetric,
 
-    # margin-based losses
-    ZeroOneLoss,
-    LogitMarginLoss,
-    PerceptronLoss,
-    HingeLoss,
-    L1HingeLoss,
-    L2HingeLoss,
-    SmoothedL1HingeLoss,
-    ModifiedHuberLoss,
-    L2MarginLoss,
-    ExpLoss,
-    SigmoidLoss,
-    DWDMarginLoss,
+  # margin-based losses
+  ZeroOneLoss,
+  LogitMarginLoss,
+  PerceptronLoss,
+  HingeLoss,
+  L1HingeLoss,
+  L2HingeLoss,
+  SmoothedL1HingeLoss,
+  ModifiedHuberLoss,
+  L2MarginLoss,
+  ExpLoss,
+  SigmoidLoss,
+  DWDMarginLoss,
 
-    # distance-based losses
-    LPDistLoss,
-    L1DistLoss,
-    L2DistLoss,
-    PeriodicLoss,
-    HuberLoss,
-    EpsilonInsLoss,
-    L1EpsilonInsLoss,
-    L2EpsilonInsLoss,
-    LogitDistLoss,
-    QuantileLoss,
-    LogCoshLoss,
+  # distance-based losses
+  LPDistLoss,
+  L1DistLoss,
+  L2DistLoss,
+  PeriodicLoss,
+  HuberLoss,
+  EpsilonInsLoss,
+  L1EpsilonInsLoss,
+  L2EpsilonInsLoss,
+  LogitDistLoss,
+  QuantileLoss,
+  LogCoshLoss,
 
-    # other losses
-    MisclassLoss,
-    PoissonLoss,
-    CrossEntropyLoss,
+  # other losses
+  MisclassLoss,
+  PoissonLoss,
+  CrossEntropyLoss,
 
-    # meta losses
-    ScaledLoss,
-    WeightedMarginLoss,
+  # meta losses
+  ScaledLoss,
+  WeightedMarginLoss,
 
-    # reexport mean
-    mean
+  # reexport mean
+  mean
 
 end # module

src/io.jl

@@ -1,26 +1,34 @@
 Base.print(io::IO, loss::SupervisedLoss, args...) = print(io, typeof(loss).name.name, args...)
 Base.print(io::IO, loss::L1DistLoss, args...) = print(io, "L1DistLoss", args...)
 Base.print(io::IO, loss::L2DistLoss, args...) = print(io, "L2DistLoss", args...)
-Base.print(io::IO, loss::LPDistLoss{P}, args...) where {P} = print(io, typeof(loss).name.name, " with P = $(P)", args...)
-Base.print(io::IO, loss::L1EpsilonInsLoss, args...) = print(io, typeof(loss).name.name, " with \$\\epsilon\$ = $(loss.ε)", args...)
-Base.print(io::IO, loss::L2EpsilonInsLoss, args...) = print(io, typeof(loss).name.name, " with \$\\epsilon\$ = $(loss.ε)", args...)
-Base.print(io::IO, loss::QuantileLoss, args...) = print(io, typeof(loss).name.name, " with \$\\tau\$ = $(loss.τ)", args...)
-Base.print(io::IO, loss::SmoothedL1HingeLoss, args...) = print(io, typeof(loss).name.name, " with \$\\gamma\$ = $(loss.gamma)", args...)
-Base.print(io::IO, loss::HuberLoss, args...) = print(io, typeof(loss).name.name, " with \$\\alpha\$ = $(loss.d)", args...)
+Base.print(io::IO, loss::LPDistLoss{P}, args...) where {P} =
+  print(io, typeof(loss).name.name, " with P = $(P)", args...)
+Base.print(io::IO, loss::L1EpsilonInsLoss, args...) =
+  print(io, typeof(loss).name.name, " with \$\\epsilon\$ = $(loss.ε)", args...)
+Base.print(io::IO, loss::L2EpsilonInsLoss, args...) =
+  print(io, typeof(loss).name.name, " with \$\\epsilon\$ = $(loss.ε)", args...)
+Base.print(io::IO, loss::QuantileLoss, args...) =
+  print(io, typeof(loss).name.name, " with \$\\tau\$ = $(loss.τ)", args...)
+Base.print(io::IO, loss::SmoothedL1HingeLoss, args...) =
+  print(io, typeof(loss).name.name, " with \$\\gamma\$ = $(loss.gamma)", args...)
+Base.print(io::IO, loss::HuberLoss, args...) =
+  print(io, typeof(loss).name.name, " with \$\\alpha\$ = $(loss.d)", args...)
 Base.print(io::IO, loss::DWDMarginLoss, args...) = print(io, typeof(loss).name.name, " with q = $(loss.q)", args...)
-Base.print(io::IO, loss::PeriodicLoss, args...) = print(io, typeof(loss).name.name, " with c = $(round(2π / loss.k, digits=1))", args...)
+Base.print(io::IO, loss::PeriodicLoss, args...) =
+  print(io, typeof(loss).name.name, " with c = $(round(2π / loss.k, digits=1))", args...)
 Base.print(io::IO, loss::ScaledLoss{T,K}, args...) where {T,K} = print(io, "$(K) * ($(loss.loss))", args...)
 
 _round(num) = round(num) == round(num, digits=1) ? round(Int, num) : round(num, digits=1)
 function _relation(num)
-    if num <= 0
-        "negative only"
-    elseif num >= 1
-        "positive only"
-    elseif num < 0.5
-        "1:$(_round((1-num)/num)) weighted"
-    else
-        "$(_round(num/(1-num))):1 weighted"
-    end
+  if num <= 0
+    "negative only"
+  elseif num >= 1
+    "positive only"
+  elseif num < 0.5
+    "1:$(_round((1-num)/num)) weighted"
+  else
+    "$(_round(num/(1-num))):1 weighted"
+  end
 end
-Base.print(io::IO, loss::WeightedMarginLoss{T,W}, args...) where {T,W} = print(io, "$(_relation(W)) $(loss.loss)", args...)
+Base.print(io::IO, loss::WeightedMarginLoss{T,W}, args...) where {T,W} =
+  print(io, "$(_relation(W)) $(loss.loss)", args...)

src/losses.jl

@@ -2,12 +2,12 @@
 Scalar = Union{Number,CategoricalValue}
 
 # fallback to unary evaluation
-(loss::DistanceLoss)(output::Number, target::Number)       = loss(output - target)
-deriv(loss::DistanceLoss, output::Number, target::Number)  = deriv(loss, output - target)
+(loss::DistanceLoss)(output::Number, target::Number) = loss(output - target)
+deriv(loss::DistanceLoss, output::Number, target::Number) = deriv(loss, output - target)
 deriv2(loss::DistanceLoss, output::Number, target::Number) = deriv2(loss, output - target)
-(loss::MarginLoss)(output::Number, target::Number)         = loss(target * output)
-deriv(loss::MarginLoss, output::Number, target::Number)    = target * deriv(loss, target * output)
-deriv2(loss::MarginLoss, output::Number, target::Number)   = deriv2(loss, target * output)
+(loss::MarginLoss)(output::Number, target::Number) = loss(target * output)
+deriv(loss::MarginLoss, output::Number, target::Number) = target * deriv(loss, target * output)
+deriv2(loss::MarginLoss, output::Number, target::Number) = deriv2(loss, target * output)
 
 # broadcasting behavior
 Broadcast.broadcastable(loss::SupervisedLoss) = Ref(loss)
@@ -34,7 +34,7 @@ include("losses/weighted.jl")
 Return sum of `loss` values over the iterables `outputs` and `targets`.
 """
 function sum(loss::SupervisedLoss, outputs, targets)
-    sum(loss(ŷ, y) for (ŷ, y) in zip(outputs, targets))
+  sum(loss(ŷ, y) for (ŷ, y) in zip(outputs, targets))
 end
 
 """
@@ -45,9 +45,9 @@ The `weights` determine the importance of each observation. The option
 `normalize` divides the result by the sum of the weights.
 """
 function sum(loss::SupervisedLoss, outputs, targets, weights; normalize=true)
-    s = sum(w * loss(ŷ, y) for (ŷ, y, w) in zip(outputs, targets, weights))
-    n = normalize ? sum(weights) : one(first(weights))
-    s / n
+  s = sum(w * loss(ŷ, y) for (ŷ, y, w) in zip(outputs, targets, weights))
+  n = normalize ? sum(weights) : one(first(weights))
+  s / n
 end
 
 """
@@ -56,7 +56,7 @@ end
 Return mean of `loss` values over the iterables `outputs` and `targets`.
 """
 function mean(loss::SupervisedLoss, outputs, targets)
-    mean(loss(ŷ, y) for (ŷ, y) in zip(outputs, targets))
+  mean(loss(ŷ, y) for (ŷ, y) in zip(outputs, targets))
 end
 
 """
@@ -67,7 +67,7 @@ The `weights` determine the importance of each observation. The option
 `normalize` divides the result by the sum of the weights.
 """
 function mean(loss::SupervisedLoss, outputs, targets, weights; normalize=true)
-    m = mean(w * loss(ŷ, y) for (ŷ, y, w) in zip(outputs, targets, weights))
-    n = normalize ? sum(weights) : one(first(weights))
-    m / n
+  m = mean(w * loss(ŷ, y) for (ŷ, y, w) in zip(outputs, targets, weights))
+  n = normalize ? sum(weights) : one(first(weights))
+  m / n
 end