Update docs

Author: bjack205

docs/make.jl

@@ -7,25 +7,19 @@ makedocs(
     pages = [
         "Introduction" => "index.md",
         "Getting Started" => [
-            "models.md",
+            "model.md",
             "costfunctions.md",
             "constraints.md",
-            "creating_problems.md",
-            "solving.md"
+            "creating_problems.md"
         ],
         "Interfaces" => [
             "costfunction_interface.md",
-            "constraint_interface.md",
-            "solver_interface.md"
+            "constraint_interface.md"
         ],
-        "Documentation" => [
-            "model_types.md",
-            "discretization.md",
+        "API" => [
             "cost_api.md",
             "constraint_api.md",
-            "problem.md",
-            "solvers.md",
-            "rotations.md"
+            "problem.md"
         ]
     ]
 )
@@ -35,6 +29,4 @@ makedocs(
 # for more information.
 deploydocs(
     repo = "github.com/RoboticExplorationLab/TrajectoryOptimization.jl.git",
-    deploy_config=Documenter.Travis(),
-    devbranch = "v1.3",
 )

docs/old/constraint_api.md

@@ -0,0 +1,64 @@
+```@meta
+CurrentModule = TrajectoryOptimization
+```
+
+# Constraints
+This page provides details about the various types in TrajectoryOptimization.jl for working
+with constraints, as well as the methods defined on those types.
+In general, a [`ConstraintList`](@ref) is used to define the constraints, and another
+[`AbstractConstraintSet`](@ref), such as an [`ALConstraintSet`](@ref), is instantiated by a
+solver to hold the constraint values and Jacobians.
+
+## Constraint List
+A [`ConstraintList`](@ref) is used to define a trajectory optimization [`Problem`](@ref) and
+only holds basic information about the constraints included in the problem. Although it is
+a child of [`AbstractConstraintSet`](@ref) and supports indexing and iteration, it does not
+hold any information about constraint values or Jacobians.
+```@docs
+ConstraintList
+add_constraint!
+num_constraints
+```
+
+## Constraint Sets
+A constraint set holding a list of [`ConVal`](@ref)s is generally instantiated by a solver
+and holds the constraint definitions, as well as the associated constraint values, Jacobians,
+and other constraint-related information required by the solver.
+```@docs
+AbstractConstraintSet
+ALConstraintSet
+link_constraints!
+```
+
+## Constraint Value type
+The [`ConVal`](@ref) type holds all the constraint values and Jacobians for a particular
+constraint, and supports different ways of storing those (either as individual matrices/vectors
+or as views into a large matrix/vector).
+
+```@docs
+ConVal
+```
+
+## Implemented Constraints
+The following is a list of the constraints currently implemented in TrajectoryOptimization.jl.
+Please refer to the docstrings for the individual constraints on details on their constructors,
+since each constraint is unique, in general.
+
+List of currently implemented constraints
+* [`GoalConstraint`](@ref)
+* [`BoundConstraint`](@ref)
+* [`CircleConstraint`](@ref)
+* [`SphereConstraint`](@ref)
+* [`NormConstraint`](@ref)
+* [`DynamicsConstraint`](@ref)
+* [`IndexedConstraint`](@ref)
+
+```@docs
+GoalConstraint
+BoundConstraint
+CircleConstraint
+SphereConstraint
+NormConstraint
+DynamicsConstraint
+IndexedConstraint
+```

docs/old/constraints.md

@@ -5,37 +5,36 @@ CurrentModule = TrajectoryOptimization
 # Constraint Interface
 
 ## Constraint Type
-All constraints inherit from `AbstractConstraint{S<:ConstraintSense,W<:ConstraintType,P}`,
-where `ConstraintSense` specifies `Inequality` or `Equality`, `ConstraintType` specifies the
-"bandedness" of the constraint (will be discussed more later), and `P` is the dimension of
-the constraint. This allows the software to easily dispatch over the type of constraint.
-Each constraint type represents a vector-valued constraint.
-The intention is that each constraint type represent one line in the constraints of
-problem definition (where they may be vector or scalar-valued).
-
+All constraints inherit from [`AbstractConstraint`](@ref).
 TrajectoryOptimization.jl assumes equality constraints are of the form ``g(x) = 0`` and inequality
 constraints are of the form ``h(x) \leq 0 ``.
 
 ```@docs
 AbstractConstraint
 ConstraintSense
-ConstraintType
 ```
 
-### Methods
-The following methods are defined for all `AbstractConstraint`s
+## Evaluating Constraints
+The following methods are used to evaluate a constraint:
 ```@docs
-state_dims
-control_dims
+evaluate
 evaluate!
 jacobian!
-contype
+∇jacobian!
+```
+
+### Methods
+The following methods are defined for all `AbstractConstraint`s
+```@docs
+state_dim
+control_dim
 sense
-width
+widths
 upper_bound
 lower_bound
 is_bound
 check_dims
+get_inds
 ```
 
 ## Adding a New Constraint
@@ -82,16 +81,12 @@ end
 
 ### Constraint Types
 The `ConstraintType` defines the "bandedness" of the constraint, or the number of adjacent
-state or constraint values needed to calculate the constraint. 
+state or constraint values needed to calculate the constraint.
 ```@docs
-Stage
-State
-Control
-Coupled
-Dynamical
-CoupledState
-CoupledControl
-General
-GeneralState
-GeneralControl
+StageConstraint
+StateConstraint
+ControlConstraint
+CoupledConstraint
+CoupledStateConstraint
+CoupledControlConstraint
 ```

docs/src/constraint_api.md

@@ -0,0 +1,50 @@
+# [3. Creating Constraints](@id constraint_section)
+```@meta
+CurrentModule = TrajectoryOptimization
+```
+
+```@contents
+Pages = ["constraints.md"]
+```
+
+## Creating Constraint Sets
+The easiest way to set up the constraints for your problem is through the [`ConstraintList`](@ref).
+This structure simply holds a vector of all the constraints in the trajectory optimization problem.
+The easiest way to start is to create an empty [`ConstraintList`](@ref):
+```julia
+cons = ConstraintList(n,m,N)
+```
+
+### Adding Constraints
+You can add any constraint (the list of currently implemented constraints is given in the following
+section) to the constraint set using the [`add_constraint!`](@ref) method. For example, if we
+want to add control limits and an final goal constraint to our problem, we do this by creating
+a `ConstraintList` and subsequently adding the constraints:
+```julia
+# Dimensions of our problem
+n,m,N = 4,1,51    # 51 knot points
+
+# Create our list of constraints
+cons = ConstraintList(n,m,N)
+
+# Create the goal constraint
+xf = [0,π,0,0]
+goalcon = GoalConstraint(xf)
+add_constraint!(cons, goalcon, N)  # add to the last time step
+
+# Create control limits
+ubnd = 3
+bnd = BoundConstraint(n,m, u_min=-ubnd, u_max=ubnd)
+add_constraint!(cons, bnd, 1:N-1)  # add to all but the last time step
+```
+
+### Defined Constraints
+The following constraints are currently defined. See their individual docstrings on details
+on how to construct them, since constraint constructors are, in general, unique to the constraint.
+
+* [`GoalConstraint`](@ref)
+* [`BoundConstraint`](@ref)
+* [`CircleConstraint`](@ref)
+* [`SphereConstraint`](@ref)
+* [`NormConstraint`](@ref)
+* [`IndexedConstraint`](@ref)

docs/old/constraint_interface.md renamed to docs/src/constraint_interface.md

@@ -5,17 +5,17 @@ CurrentModule = TrajectoryOptimization
 # Cost Functions and Objectives
 This page details the functions related to building and evaluating cost functions and objectives.
 
-## Quadratic Cost Functions
+
+## Cost Functions
 ```@docs
+CostFunction
+QuadraticCostFunction
+DiagonalCost
 QuadraticCost
 LQRCost
-LQRCostTerminal
-LQRObjective
-```
-
-## Indexed Cost Functions
-```@docs
-IndexedCost
+is_diag
+is_blockdiag
+invert!
 ```
 
 ## Adding Cost Functions
@@ -36,19 +36,23 @@ cost3 = cost1 + cost2
 # cost3 is equivalent to QuadraticCost(Q1+Q2, R1+R2)
 ```
 
-## CostExpansion Type
-The `CostExpansion` type stores the pieces of the second order Taylor expansion of the cost for the entire trajectory, stored as vectors of Static Vectors or Static Matrices. e.g. to get the Hessian with respect to `x` at knotpoint 5 you would use `E.xx[5]`.
+## Objectives
 ```@docs
-CostExpansion
+Objective
+LQRObjective
+get_J
+dgrad
+dhess
+norm_grad
 ```
 
-## Objective
+## Evaluating the Cost
 ```@docs
-Objective
-cost(::Objective, Z::Traj)
-get_J
-cost_gradient
+cost
+stage_cost
+gradient!
+hessian!
 cost_gradient!
-cost_hessian
 cost_hessian!
+cost_expansion!
 ```