Helper function: Get name of adjoint derivative function

Run a command with a timeout after which it will be forcibly killed.

* s e t */

\brief Add an integer attribute \identifier{252} */

* s o l v e */

\brief Propagate sparsity forward */

Construct an event transition function, default naming

! \fn int DSDPBlockASum(DSDPBlockData *ADATA, double aa, DSDPVec Yk, DSDPVMat XX){ \brief Sum the data matrices. \param ADATA block of data. \param aa

! \fn int DSDPBlockAddDataMatrix(DSDPBlockData *ADATA,int vari, struct DSDPDataMat_Ops* dsdpdataops, void* data){ \brief Add data matrix into SDP bl

! \fn int DSDPBlockDataAllocate(DSDPBlockData *ADATA, int nnz); \brief Allocate some structures. \param ADATA block of data. \param nnz number of data

! \fn int DSDPBlockDataInitialize(DSDPBlockData *ADATA){ \brief Set pointers to null. \param ADATA block of data. */

! \fn int DSDPBlockDataMarkNonzeroMatrices(DSDPBlockData *ADATA, int *annz){ \brief Mark which variable in block have a data matrix. \param ADATA bloc

! \fn int DSDPBlockTakeDownData(DSDPBlockData *ADATA){ \brief Free structures in block of data. \param ADATA block of data. */

! \fn int int DSDPBlockvAv(DSDPBlockData *ADATA, double aa, DSDPVec Alpha, SDPConeVec V, DSDPVec VAV){ \brief Set VAV[i] to aa * Alpha[i] * V' A[i] V

! \fn int DSDPComputeDataNorms(DSDP dsdp); \brief Compute norms of A,C, and b. \param dsdp the solver */

! \fn int DSDPComputeG( DSDP dsdp , DSDPVec vt, DSDPVec vrhs1, DSDPVec vrhs2); \param dsdp the solver \param vt scaling for each element in the next t

! \fn int DSDPComputePNorm(DSDP dsdp, double mu, DSDPVec DY, double *pnorm); \brief Compute proximity to a point on the central path. \param dsdp th

! \fn int DSDPDSMatInitialize(DSDPDSMat *B); \brief Set pointers to null. \param B pointer to matrix. */

! \fn int DSDPDSMatSetArray(DSDPDSMat A, DSDPVMat T); \brief Set values into the matrix. \param A symmetric DS matrix \param T Source of entries in de

! \fn int DSDPDataMatAddMultiple(DSDPDataMat A, double ytmp, double *v, int nn, int n); \brief Add a multiple the data matrix to the array. \param A

! \fn int DSDPDataMatDot(DSDPDataMat A, double x[], int nn, int n, double *v); \brief Compute inner product of data with a dense matrix \param A symm

! \fn int DSDPDataMatInitialize(DSDPDataMat *A); \brief Set pointers to NULL; \param A symmetric data matrix */

! \fn int DSDPDataMatVecVec(DSDPDataMat A, SDPConeVec W, double *v); \brief Compute w' A w \param A symmetric data matrix \param W vector \param v th

! \fn int DSDPDataMatView(DSDPDataMat A); \brief Print matrix \param A symmetric data matrix */

! \fn int DSDPDataTransposeInitialize(DSDPDataTranspose *ATranspose); \brief Initialize transpose structure for data. \param ATranspose transpose stru

! \fn int DSDPDataTransposeTakeDown(DSDPDataTranspose *ATranspose); \brief Free transpose structure for data. \param ATranspose transpose structure fo

! \fn int DSDPDualMatDestroy(DSDPDualMat *S); \brief Free the matrix structure \param S dual matrix */

! \fn int DSDPDualMatInitialize(DSDPDualMat *S); \brief Set pointers to null. \param S dual matrix */

! \fn int DSDPDualMatInverseAdd(DSDPDualMat S, double alpha, DSDPVMat T); \brief Add a multiple of the inverse to T. \param S dual matrix \param alpha

! \fn int DSDPDualMatInvert(DSDPDualMat S); \brief Invert the matrix. \param S dual matrix Assumes Cholesky factorization was successful. This routin

! \fn int DSDPLanczosInitialize( DSDPLanczosStepLength *LZ ); \brief Initialize Lanczos structure. \param LZ structure. */

! \fn int DSDPMakeVMat(char UPLQ, int n, DSDPVMat *X); \brief Allocate V matrix. \param UPLQ format \param n dimension \param X new matrix. \sa SDPCon

! \fn int DSDPObjectiveGH( DSDP dsdp , DSDPSchurMat M, DSDPVec vrhs1); \param dsdp solver \param M Schur matrix. \param vrhs1 gradient vector \brief C

! \fn int DSDPSchurMatAddDiagonal(DSDPSchurMat M, DSDPVec D); \brief Add elements to a row of the Schur matrix. \param M matrix \param D diagonal ele