Update

docs/make.jl

@@ -116,7 +116,7 @@ Documenter.makedocs(
             "developer/contributing.md",
             "developer/credits.md",
         ],
-        "API" => ["atoms.md", "reformulations.md"],
+        "atoms.md",
         "reference.md",
         "release_notes.md",
     ],

docs/src/atoms.md

@@ -1,37 +1,15 @@
 # Atoms
 
-## AbsAtom
-
-```@docs
-Convex.AbsAtom
-```
-
-## ExpAtom
-
-```@docs
-Convex.ExpAtom
-```
-
-## LogAtom
-
-```@docs
-Convex.LogAtom
-```
-
-## LogSumExpAtom
-
-```@docs
-Convex.LogSumExpAtom
-```
-
-## MaxAtom
-
-```@docs
-Convex.MaAtom
-```
-
-## MinAtom
-
 ```@docs
-Convex.MinAtom
+Base.abs(::Convex.AbstractExpr)
+Base.abs2(::Convex.AbstractExpr)
+Base.exp(::Convex.AbstractExpr)
+Convex.hinge_loss
+Base.log(::Convex.AbstractExpr)
+Convex.logisticloss
+Convex.logsumexp
+Base.min(::Convex.AbstractExpr, ::Convex.AbstractExpr)
+Base.max(::Convex.AbstractExpr, ::Convex.AbstractExpr)
+Convex.neg
+Convex.pos
 ```

src/atoms/AbsAtom.jl

@@ -3,15 +3,17 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-"""
-    AbsAtom(x::AbstractExpr)
+mutable struct AbsAtom <: AbstractExpr
+    children::Tuple{AbstractExpr}
+    size::Tuple{Int,Int}
 
-The epigraph of \$|x|\$.
+    AbsAtom(x::AbstractExpr) = new((x,), x.size)
+end
 
-## Related constructors
+"""
+    Base.abs(x::Convex.AbstractExpr)
 
- * `Base.abs(x)`
- * `Base.abs2(x)`
+The epigraph of \$|x|\$.
 
 ## Examples
 
@@ -51,13 +53,6 @@ abs (convex; positive)
 | :--- | :----------- | :-------- |
 | Positive | depends on the sign of \$x\$ | Convex |
 """
-mutable struct AbsAtom <: AbstractExpr
-    children::Tuple{AbstractExpr}
-    size::Tuple{Int,Int}
-
-    AbsAtom(x::AbstractExpr) = new((x,), x.size)
-end
-
 Base.abs(x::AbstractExpr) = AbsAtom(x)
 
 head(io::IO, ::AbsAtom) = print(io, "abs")

src/atoms/ExpAtom.jl

@@ -3,14 +3,24 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-"""
-    ExpAtom(x::AbstractExpr)
+mutable struct ExpAtom <: AbstractExpr
+    children::Tuple{AbstractExpr}
+    size::Tuple{Int,Int}
 
-The epigraph of \$e^x\$.
+    function ExpAtom(x::AbstractExpr)
+        if sign(x) == ComplexSign()
+            error(
+                "[ExpAtom] the argument should be real but it's instead complex",
+            )
+        end
+        return new((x,), x.size)
+    end
+end
 
-## Related constructors
+"""
+    Base.exp(x::Convex.AbstractExpr)
 
- * `Base.exp(x)`
+The epigraph of \$e^x\$.
 
 ## Examples
 
@@ -50,20 +60,6 @@ exp (convex; positive)
 | :--- | :----------- | :-------- |
 | Positive | Nondecreasing | Convex |
 """
-mutable struct ExpAtom <: AbstractExpr
-    children::Tuple{AbstractExpr}
-    size::Tuple{Int,Int}
-
-    function ExpAtom(x::AbstractExpr)
-        if sign(x) == ComplexSign()
-            error(
-                "[ExpAtom] the argument should be real but it's instead complex",
-            )
-        end
-        return new((x,), x.size)
-    end
-end
-
 Base.exp(x::AbstractExpr) = ExpAtom(x)
 
 head(io::IO, ::ExpAtom) = print(io, "exp")

src/atoms/LogAtom.jl

@@ -3,14 +3,24 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-"""
-    LogAtom(x::AbstractExpr)
+mutable struct LogAtom <: AbstractExpr
+    children::Tuple{AbstractExpr}
+    size::Tuple{Int,Int}
 
-The hypograph of \$\\log(x)\$.
+    function LogAtom(x::AbstractExpr)
+        if sign(x) == ComplexSign()
+            error(
+                "[LogAtom] the argument should be real but it's instead complex",
+            )
+        end
+        return new((x,), x.size)
+    end
+end
 
-## Related constructors
+"""
+    Base.log(x::Convex.AbstractExpr)
 
- * `Base.log(x)`
+The hypograph of \$\\log(x)\$.
 
 ## Examples
 
@@ -50,20 +60,6 @@ log (concave; real)
 | :--- | :----------- | :-------- |
 | None | Nondecreasing | Concave |
 """
-mutable struct LogAtom <: AbstractExpr
-    children::Tuple{AbstractExpr}
-    size::Tuple{Int,Int}
-
-    function LogAtom(x::AbstractExpr)
-        if sign(x) == ComplexSign()
-            error(
-                "[LogAtom] the argument should be real but it's instead complex",
-            )
-        end
-        return new((x,), x.size)
-    end
-end
-
 Base.log(x::AbstractExpr) = LogAtom(x)
 
 head(io::IO, ::LogAtom) = print(io, "log")

src/atoms/LogSumExpAtom.jl

@@ -3,15 +3,24 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-"""
-    LogSumExpAtom(x::AbstractExpr)
+mutable struct LogSumExpAtom <: AbstractExpr
+    children::Tuple{AbstractExpr}
+    size::Tuple{Int,Int}
 
-The epigraph of \$\\log\\left(\\sum_i e^{x_i}\\right)\$.
+    function LogSumExpAtom(x::AbstractExpr)
+        if sign(x) == ComplexSign()
+            error(
+                "[LogSumExpAtom] the argument should be real but it's instead complex",
+            )
+        end
+        return new((x,), (1, 1))
+    end
+end
 
-## Related constructors
+"""
+    logsumexp(x::Convex.AbstractExpr)
 
- * [`logsumexp`](@ref)
- * [`logisticloss`](@ref)
+The epigraph of \$\\log\\left(\\sum_i e^{x_i}\\right)\$.
 
 ## Examples
 
@@ -36,27 +45,6 @@ logsumexp (convex; real)
 | :--- | :----------- | :-------- |
 | None | Nondecreasing | Convex   |
 """
-mutable struct LogSumExpAtom <: AbstractExpr
-    children::Tuple{AbstractExpr}
-    size::Tuple{Int,Int}
-
-    function LogSumExpAtom(x::AbstractExpr)
-        if sign(x) == ComplexSign()
-            error(
-                "[LogSumExpAtom] the argument should be real but it's instead complex",
-            )
-        end
-        return new((x,), (1, 1))
-    end
-end
-
-"""
-    logsumexp(x::AbstractExpr)
-
-The epigraph of \$\\log\\left(\\sum_i e^{x_i}\\right)\$.
-
-See [`LogSumExpAtom`](@ref).
-"""
 logsumexp(x::AbstractExpr) = LogSumExpAtom(x)
 
 head(io::IO, ::LogSumExpAtom) = print(io, "logsumexp")

src/atoms/MaxAtom.jl

@@ -3,14 +3,37 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-"""
-    MaxAtom(x::AbstractExpr, y::AbstractExpr)
+mutable struct MaxAtom <: AbstractExpr
+    children::Tuple{AbstractExpr,AbstractExpr}
+    size::Tuple{Int,Int}
 
-The hypograph of \$max(x, y)\$.
+    function MaxAtom(x::AbstractExpr, y::AbstractExpr)
+        if sign(x) == ComplexSign() || sign(y) == ComplexSign()
+            error(
+                "[MaxAtom] both the arguments should be real instead they are $(sign(x)) and $(sign(y))",
+            )
+        end
+        sz = if x.size == y.size
+            x.size
+        elseif x.size == (1, 1)
+            y.size
+        elseif y.size == (1, 1)
+            x.size
+        else
+            error(
+                "[MaxAtom] got different sizes for x as $(x.size) and y as $(y.size)",
+            )
+        end
+        return new((x, y), sz)
+    end
+end
 
-## Related constructors
+"""
+    Base.max(x::Convex.AbstractExpr, y::Convex.AbstractExpr)
+    Base.max(x::Convex.AbstractExpr, y::Convex.Value)
+    Base.max(x::Convex.Value, y::Convex.AbstractExpr)
 
- * `Base.max(x, y)`
+The hypograph of \$max(x, y)\$.
 
 ## Examples
 
@@ -38,31 +61,6 @@ max (convex; real)
 └─ [1; 2; 3;;]
 ```
 """
-mutable struct MaxAtom <: AbstractExpr
-    children::Tuple{AbstractExpr,AbstractExpr}
-    size::Tuple{Int,Int}
-
-    function MaxAtom(x::AbstractExpr, y::AbstractExpr)
-        if sign(x) == ComplexSign() || sign(y) == ComplexSign()
-            error(
-                "[MaxAtom] both the arguments should be real instead they are $(sign(x)) and $(sign(y))",
-            )
-        end
-        sz = if x.size == y.size
-            x.size
-        elseif x.size == (1, 1)
-            y.size
-        elseif y.size == (1, 1)
-            x.size
-        else
-            error(
-                "[MaxAtom] got different sizes for x as $(x.size) and y as $(y.size)",
-            )
-        end
-        return new((x, y), sz)
-    end
-end
-
 Base.max(x::AbstractExpr, y::AbstractExpr) = MaxAtom(x, y)
 
 Base.max(x::AbstractExpr, y::Value) = max(x, constant(y))