@{ \brief Generate a function that calculates \a nfwd forward derivatives \identifier{hh} */

@{ \brief Return Jacobian of all input elements with respect to all output elements \identifier{xx} */

@{ Is the class able to propagate seeds through the algorithm?

\brief Sparse LDL^T factorization * Returns D and the strictly upper triangular entries of L^T * I.e. ones on the diagonal are ignored.

\brief Find first nonzero * If failed, returns the number of rows \identifier{r8} */

Number of (scalarised) decision variables

Type of parallellization

Print a (typically 64-bit) unsigned integer

* r e m o v e I n d e x */

* s e t u p A l l I n a c t i v e */

* t h r o w W a r n i n g */

Convert scalar to matrix

! \fn int BoundYConeSetBounds(LUBounds lucone, double lb, double ub); \brief Set bounds on the variables \param lucone cone of bounds. \param lb lower

Checks for a C-style cast by looking for the pattern. Args: filename: The name of the current file. linenum: The number of the line to chec

Removes //-comments and single-line C-style /* */ comments. Args: line: A line of C++ source. Returns: The line with single-line comment

! \fn int DSDPBlockRemoveDataMatrix(DSDPBlockData *ADATA, int vari); \brief Remove a data matrix. \param ADATA block of data. \param vari variable cor

! \fn int DSDPDSMatSetData(DSDPDSMat *M, struct DSDPDSMat_Ops* ops, void*data); \brief Set the opaque pointer and function pointers to the matrix. \

! \fn int DSDPDataMatDestroy(DSDPDataMat *A); \brief Free the data structures \param A symmetric data matrix */

! \fn int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2); \brief Compute the square of the Frobenius norm \param A symmetric data matrix. \

! \fn int DSDPDataMatSetData(DSDPDataMat *A, struct DSDPDataMat_Ops* ops, void*data); \brief Set the opaque pointer and function pointers to the mat

! \fn int DSDPDualMatCholeskySolveBackward(DSDPDualMat S, SDPConeVec B, SDPConeVec X); \brief Backward triangular solve. \param S dual matrix \param

! \fn int DSDPDualMatCholeskySolveForward(DSDPDualMat S, SDPConeVec B, SDPConeVec X); \brief Forward triangular solve. \param S dual matrix \param B

! \fn int DSDPSchurMatInParallel(DSDPSchurMat M, DSDPTruth *flag); \brief Determine whether M is computed in parallel. \param M matrix \param flag t

! \fn int DSDPSchurMatRowColumnScaling(DSDPSchurMat M, int row, DSDPVec V, int *nzcols); \brief Get the scaling and nonzero pattern of each column in

! \fn int DSDPSchurMatSetData(DSDPSchurMat *M, struct DSDPSchurMat_Ops* ops, void*data); \brief Set the Schur matrix with an opaque pointer and struc

! \fn int DSDPSchurMatSetR(DSDPSchurMat M, double rr); \brief Set up the data structure \param M matrix \param rr residual */

! \fn int DSDPVMatExist(DSDPVMat X, int *flag); \brief Answer whether the array has been allocated or not. \param X dense symmetric matrix \param flag

! \fn int DSDPVMatInitialize(DSDPVMat *B); \brief Set pointers to null \param B dense symmetric matrix */