Fix some test issues

Author: bjack205

Project.toml

@@ -16,6 +16,6 @@ UnsafeArrays = "c4a57d5a-5b31-53a6-b365-19f8c011fbd6"
 DocStringExtensions = "0.8"
 ForwardDiff = "0.10"
 MathOptInterface = "0.9"
-RobotDynamics = "0.1.3"
+RobotDynamics = "0.1.2"
 StaticArrays = "0.12"
 UnsafeArrays = "1"

docs/make.jl

@@ -19,7 +19,8 @@ makedocs(
         "API" => [
             "cost_api.md",
             "constraint_api.md",
-            "problem.md"
+            "problem.md",
+            "nlp.md"
         ]
     ]
 )

docs/src/nlp.md

@@ -0,0 +1,73 @@
+```@meta
+CurrentModule = TrajectoryOptimization
+```
+
+# Converting to an NLP
+
+```@contents
+Pages = ["nlp.md"]
+```
+
+Trajectory optimization problems are really just nonlinear programs (NLPs). A handful of
+high-quality NLP solvers exist, such as Ipopt, Snopt, and KNITRO. TrajectoryOptimization
+provides an interface that allows methods that are amenable to use with a general-purpose
+NLP solver. In the NLP, the states and constraints at every knot point are concatenated into
+a single large vector of decision variables, and the cost hessian and constraint Jacobians
+are represented as large, sparse matrices.
+
+## Important Types
+Below is the documentation for the types used to represent a trajectory optimization problem
+as an NLP:
+
+```@docs
+NLPData
+NLPConstraintSet
+QuadraticViewCost
+ViewKnotPoint
+TrajData
+NLPTraj
+```
+
+## The `TrajOptNLP` type
+The most important type is the [`TrajOptNLP`](@ref), which is a single struct that has all
+the required methods to evaluate the trajectory optimization problem as an NLP.
+
+```@docs
+TrajOptNLP
+```
+
+### Interface
+Use the following methods on a `TrajOptNLP` `nlp`. Unless otherwise noted, `Z` is a single
+vector of `NN` decision variables (where `NN` is the total number of states and controls across
+all knot points).
+```@docs
+eval_f
+grad_f!
+hess_f!
+hess_f_structure
+eval_c!
+jac_c!
+jacobian_structure
+hess_L!
+```
+
+The following methods are useful to getting important information that is typically required
+by an NLP solver
+```@docs
+primal_bounds!
+constraint_type
+```
+
+## MathOptInterface
+The `TrajOptNLP` can be used to set up an `MathOptInterface.AbstractOptimizer` to solve
+the trajectory optimization problem. For example if we want to use Ipopt and have already
+set up our `TrajOptNLP`, we can solve it using `build_MOI!(nlp, optimizer)`:
+
+```julia
+using Ipopt
+using MathOptInterface
+nlp = TrajOptNLP(...)  # assume this is already set up
+optimizer = Ipopt.Optimizer()
+TrajectoryOptimization.build_MOI!(nlp, optimizer)
+MathOptInterface.optimize!(optimizer)
+```

src/constraint_list.jl

@@ -124,7 +124,7 @@ end
 
 # Iteration
 Base.iterate(cons::ConstraintList) = length(cons) == 0 ? nothing : (cons[1], 1)
-Base.iterate(cons::ConstraintList, i) = i < length(cons) ? (cons[i+1], i+1) : nothing
+Base.iterate(cons::ConstraintList, i::Int) = i < length(cons) ? (cons[i+1], i+1) : nothing
 @inline Base.length(cons::ConstraintList) = length(cons.constraints)
 Base.IteratorSize(::ConstraintList) = Base.HasLength()
 Base.IteratorEltype(::ConstraintList) = Base.HasEltype()
@@ -150,7 +150,7 @@ end
 	num_constraints(::TrajOptNLP)
 
 Return a vector of length `N` constaining the total number of constraint values at each
-knot point. 
+knot point.
 """
 @inline num_constraints(cons::ConstraintList) = cons.p
 

src/nlp.jl

@@ -1,4 +1,20 @@
 #--- NLPData
+"""
+Holds all the required data structures for evaluating a trajectory optimization problem as
+	an NLP. It represents the cost gradient, Hessian, constraints, and constraint Jacobians
+	as large, sparse arrays, as applicable.
+
+# Constructors
+	NLPData(G, g, zL, zU, D, d, λ)
+	NLPData(G, g, zL, zU, D, d, λ, v, r, c)
+	NLPData(NN, P, [nD])  # suggested constructor
+
+where `G` and `g` are the cost function gradient and hessian of size `(NN,NN)` and `(NN,)`,
+`zL` and `zU` are the lower and upper bounds on the `NN` primal variables,
+`D` and `d` are the constraint jacobian and violation of size `(P,NN)` and `(P,)`, and
+`v`, `r`, `c` are the values, rows, and columns of the non-zero elements of the costraint
+Jacobian, all of length `nD`.
+"""
 mutable struct NLPData{T}
 	G::SparseMatrixCSC{T,Int}
 	g::Vector{T}
@@ -49,6 +65,8 @@ end
 	NLPConstraintSet{T}
 
 Constraint set that updates views to the NLP constraint vector and Jacobian.
+
+The views can be reset to new arrays using `reset_views!(::NLPConstraintSet, ::NLPData)`
 """
 struct NLPConstraintSet{T} <: AbstractConstraintSet
     convals::Vector{ConVal}
@@ -375,7 +393,7 @@ mutable struct NLPOpts{T}
 end
 
 function NLPOpts(;
-		reset_views::Bool = false 
+		reset_views::Bool = false
 		)
 	NLPOpts{Float64}(reset_views)
 end
@@ -493,7 +511,8 @@ end
 """
 	grad_f!(nlp::TrajOptNLP, Z, g)
 
-Evaluate the gradient of the cost function
+Evaluate the gradient of the cost function for the vector of decision variables `Z`, storing
+	the result in the vector `g`.
 """
 function grad_f!(nlp::TrajOptNLP, Z=get_primals(nlp), g=nlp.data.g)
 	N = num_knotpoints(nlp)
@@ -513,7 +532,8 @@ end
 """
 	hess_f!(nlp::TrajOptNLP, Z, G)
 
-Evaluate the hessian of the cost function `G`.
+Evaluate the hessian of the cost function for the vector of decision variables `Z`,
+	storing the result in `G`, a sparse matrix.
 """
 function hess_f!(nlp::TrajOptNLP, Z=get_primals(nlp), G=nlp.data.G)
 	N = num_knotpoints(nlp)
@@ -623,7 +643,7 @@ function jac_c!(nlp::TrajOptNLP, Z=get_primals(nlp), C::AbstractArray=nlp.data.D
 end
 
 """
-	jac_structure(nlp::TrajOptNLP)
+	jacobian_structure(nlp::TrajOptNLP)
 
 Returns a sparse matrix `D` of the same size as the constraint Jacobian, corresponding to
 the sparsity pattern of the constraint Jacobian. Additionally, `D[i,j]` is either zero or