#ifndef QDLDL_H
#define QDLDL_H

# ifdef __cplusplus
extern "C" {
# endif // ifdef __cplusplus

/**
  * Compute the elimination tree for a quasidefinite matrix
  * in compressed sparse column form, where the input matrix is
  * assumed to contain data for the upper triangular part of A only,
  * and there are no duplicate indices.
  *
  * Returns an elimination tree for the factorization A = LDL^T and a
  * count of the nonzeros in each column of L that are strictly below the
  * diagonal.
  *
  * Does not use MALLOC.  It is assumed that the arrays work, Lnz, and
  * etree will be allocated with a number of elements equal to n.
  *
  * The data in (n,Ap,Ai) are from a square matrix A in CSC format, and
  * should include the upper triangular part of A only.
  *
  * This function is only intended for factorisation of QD matrices specified
  * by their upper triangular part.  An error is returned if any column has
  * data below the diagonal or s completely empty.
  *
  * For matrices with a non-empty column but a zero on the corresponding diagonal,
  * this function will *not* return an error, as it may still be possible to factor
  * such a matrix in LDL form.   No promises are made in this case though...
  *
  * @param  n      number of columns in CSC matrix A (assumed square)
  * @param  Ap     column pointers (size n+1) for columns of A
  * @param  Ai     row indices of A.  Has Ap[n] elements
  * @param  work   work vector (size n) (no meaning on return)
  * @param  Lnz    count of nonzeros in each column of L (size n) below diagonal
  * @param  etree  elimination tree (size n)
  * @return total  sum of Lnz (i.e. total nonzeros in L below diagonal).
  *                Returns -1 if the input is not triu or has an empty column.
  *                Returns -2 if the return value overflows int.
  *
*/
int QDLDL_etree( const int n, const int *Ap, const int *Ai, int *work, int* Lnz, int* etree );


/**
  * Compute an LDL decomposition for a quasidefinite matrix
  * in compressed sparse column form, where the input matrix is
  * assumed to contain data for the upper triangular part of A only,
  * and there are no duplicate indices.
  *
  * Returns factors L, D and Dinv = 1./D.
  *
  * Does not use MALLOC.  It is assumed that L will be a compressed
  * sparse column matrix with data (n,Lp,Li,Lx)  with sufficient space
  * allocated, with a number of nonzeros equal to the count given
  * as a return value by QDLDL_etree
  *
  * @param  n      number of columns in L and A (both square)
  * @param  Ap     column pointers (size n+1) for columns of A (not modified)
  * @param  Ai     row indices of A.  Has Ap[n] elements (not modified)
  * @param  Ax     data of A.  Has Ap[n] elements (not modified)
  * @param  Lp     column pointers (size n+1) for columns of L
  * @param  Li     row indices of L.  Has Lp[n] elements
  * @param  Lx     data of L.  Has Lp[n] elements
  * @param  D      vectorized factor D.  Length is n
  * @param  Dinv   reciprocal of D.  Length is n
  * @param  Lnz    count of nonzeros in each column of L below diagonal,
  *                as given by QDLDL_etree (not modified)
  * @param  etree  elimination tree as as given by QDLDL_etree (not modified)
  * @param  bwork  working array of bools. Length is n
  * @param  iwork  working array of integers. Length is 3*n
  * @param  fwork  working array of floats. Length is n
  * @return        Returns a count of the number of positive elements
  *                in D.  Returns -1 and exits immediately if any element
  *                of D evaluates exactly to zero (matrix is not quasidefinite
  *                or otherwise LDL factorisable)
  *
*/
 int QDLDL_factor( const int n, const int *Ap, const int *Ai, const double *Ax,
                   int *Lp, int *Li, double *Lx, double *D, double *Dinv, const int *Lnz,
                   const int *etree, int *bwork, int* iwork, double *fwork );
/**
  * Solves LDL'x = b
  *
  * It is assumed that L will be a compressed
  * sparse column matrix with data (n,Lp,Li,Lx).
  *
  * @param  n      number of columns in L
  * @param  Lp     column pointers (size n+1) for columns of L
  * @param  Li     row indices of L.  Has Lp[n] elements
  * @param  Lx     data of L.  Has Lp[n] elements
  * @param  Dinv   reciprocal of D.  Length is n
  * @param  x      initialized to b.  Equal to x on return
  *
*/
 void QDLDL_solve( const int n, const int *Lp, const int *Li, const double *Lx, const double *Dinv, double *x );
/**
 * Solves (L+I)x = b
 *
 * It is assumed that L will be a compressed
 * sparse column matrix with data (n,Lp,Li,Lx).
 *
 * @param  n      number of columns in L
 * @param  Lp     column pointers (size n+1) for columns of L
 * @param  Li     row indices of L.  Has Lp[n] elements
 * @param  Lx     data of L.  Has Lp[n] elements
 * @param  x      initialized to b.  Equal to x on return
 *
*/
 void QDLDL_Lsolve( const int n, const int *Lp, const int *Li, const double *Lx, double *x );

/**
 * Solves (L+I)'x = b
 *
 * It is assumed that L will be a compressed
 * sparse column matrix with data (n,Lp,Li,Lx).
 *
 * @param  n      number of columns in L
 * @param  Lp     column pointers (size n+1) for columns of L
 * @param  Li     row indices of L.  Has Lp[n] elements
 * @param  Lx     data of L.  Has Lp[n] elements
 * @param  x      initialized to b.  Equal to x on return
 *
*/
void QDLDL_Ltsolve( const int n, const int *Lp, const int *Li, const double* Lx, double *x );

# ifdef __cplusplus
}
# endif // ifdef __cplusplus

#endif // ifndef QDLDL_H
