improve docs

Author: hexaeder

docs/src/index.md

@@ -19,14 +19,15 @@ nothing #hide
 
 # Basic Usage & Algorithms
 All of the algorithms follow the [Layout Interface](@ref). Each layout algorithm
-is represented by a type `Algorithm <: AbstractLayout`. The parameters of each
-algorithm can be set with keyword arguments. The `Algorithm` object itself is
+is represented by a type `LayoutAlgorithm <: AbstractLayout`. The parameters of each
+layout can be set with keyword arguments. The `LayoutAlgorithm` object itself is
 callable and transforms the adjacency matrix and returns a list of `Point{N,T}` from [`GeometryBasics.jl`](https://github.com/JuliaGeometry/GeometryBasics.jl).
 
 ```
-alg = Algorithm(; p1="foo", p2=:bar)
+alg = LayoutAlgorithm(; p1="foo", p2=:bar)
 positions = alg(adj_matrix)
 ```
+Instead of using the adjacency matrix you can use `AbstractGraph` types from [`LightGraphs.jl`](https://github.com/JuliaGraphs/LightGraphs.jl) directly.
 
 ## Scalable Force Directed Placement
 ```@docs

docs/src/interface.md

@@ -6,21 +6,21 @@ CurrentModule = NetworkLayout
 
 At its core, each layout algorithm is a mapping 
 ```
-adj_matrix ↦ node_positions
+graph ↦ node_positions
 ```
-where each algorithm has several parameters. The main goal of the following interface is to keep the separation between parameters and function call. 
-Each Algorithm is implemented as subtype of [`AbstractLayout`](@ref).
+where each layout has several parameters. The main goal of the following interface is to keep the separation between parameters and function call. 
+Each layout is implemented as subtype of [`AbstractLayout`](@ref).
 
 ```@docs
 AbstractLayout
 ```
 
-Therefore, each `Algorithm <: AbstractLayout` is a functor and can be passed around as a function `adj_matrix ↦ node_positions` which encapsulates all the parameters. This is handy for plotting libraries such as [GraphMakie.jl](http://juliaplots.org/GraphMakie.jl/previews/PR9/).
+Therefore, each `Layout <: AbstractLayout` is a functor and can be passed around as a function `graph ↦ node_positions` which encapsulates all the parameters. This is handy for plotting libraries such as [GraphMakie.jl](http://juliaplots.org/GraphMakie.jl/previews/PR9/).
 
 There are some additional guidelines:
 - All of the parameters should be keyword arguments, i.e. it should be allways
-  possible to call `Algorithm()` without specifying any parameters.
-- Algorithms should allways return `Vector{Point{dim,Ptype}}`. If the type or
+  possible to call `Layout()` without specifying any parameters.
+- Algorithms should allways return `Vector{Point{Dim,Ptype}}`. If the type or
   dimensions can be altered use the keywords `dim` and `Ptype` for it.
 - Some parameters may depend on the specific network (i.e. length of start
   positions vector). If possible, there should be a fallback option (i.e.

src/NetworkLayout.jl

@@ -18,6 +18,10 @@ implement
 which takes the adjacency matrix representation of a network and returns a list of
 node positions. Each `Layout` object holds all of the necessary parameters.
 
+The type parameters specify the returntype `Vector{Point{Dim,Ptype}}`:
+- `Dim`: the dimensionality of the layout (i.e. 2 or 3)
+- `Ptype`: the type of the returned points (i.e. `Float32` or `Float64`)
+
 By implementing `layout` the Layout also inherits the function-like property
 
     Layout(; kwargs...)(adj_matrix) -> node_positions