int Basker<Int,Entry,Exe_Space>::GetL(Int *n, Int *nnz,
Int **col_ptr, Int **row_idx,
Entry **val)
{
int err = get_L(n,nnz,col_ptr, row_idx, val);
return err;
}//end GetL()
int Basker<Int,Entry,Exe_Space>::GetL(Int &n, Int &nnz,
Int **col_ptr, Int **row_idx,
Entry **val)
{
get_L(n,nnz,col_ptr, row_idx, val);
return BASKER_SUCCESS;
}//end GetL()
* Adjoint code for the ludecomp
* \param _M
* \param _dfclu
*/
dmatrix ludecomp_for_adjoint(const dmatrix & _M, const cltudecomp & _dfclu)
{
ADUNCONST(dmatrix, M)
ADUNCONST(cltudecomp, dfclu)
int mmin = M.indexmin();
int mmax = M.indexmax();
cltudecomp_for_adjoint clu(mmin, mmax, 3, 2);
// get upper and lower parts of LU
dmatrix_for_adjoint & alpha = clu.get_L();
dmatrix_for_adjoint & gamma = clu.get_U(); // gamma is the transpose of beta
dmatrix & dfalpha = dfclu.get_L();
dmatrix & dfgamma = dfclu.get_U();
// copy M into alpha and gamma
// OUTER LOOP1
int i = 0;
int j = 0;
for (i = mmin; i <= mmax; i++)
{
for (int j = mmin; j <= mmax; j++)
{
clu(i, j) = M(i, j);
}
}
// OUTER LOOP2
for (j = mmin; j <= mmax; j++)
{
GLOBAL Int UMFPACK_get_numeric
(
Int Lp [ ],
Int Lj [ ],
double Lx [ ],
#ifdef COMPLEX
double Lz [ ],
#endif
Int Up [ ],
Int Ui [ ],
double Ux [ ],
#ifdef COMPLEX
double Uz [ ],
#endif
Int P [ ],
Int Q [ ],
double Dx [ ],
#ifdef COMPLEX
double Dz [ ],
#endif
Int *p_do_recip,
double Rs [ ],
void *NumericHandle
)
{
/* ---------------------------------------------------------------------- */
/* local variables */
/* ---------------------------------------------------------------------- */
NumericType *Numeric ;
Int getL, getU, *Rperm, *Cperm, k, nn, n_row, n_col, *Wi, *Pattern,
n_inner ;
double *Rs1 ;
Entry *D ;
#ifndef NDEBUG
init_count = UMF_malloc_count ;
#endif
Wi = (Int *) NULL ;
Pattern = (Int *) NULL ;
/* ---------------------------------------------------------------------- */
/* check input parameters */
/* ---------------------------------------------------------------------- */
Numeric = (NumericType *) NumericHandle ;
if (!UMF_valid_numeric (Numeric))
{
return (UMFPACK_ERROR_invalid_Numeric_object) ;
}
n_row = Numeric->n_row ;
n_col = Numeric->n_col ;
nn = MAX (n_row, n_col) ;
n_inner = MIN (n_row, n_col) ;
/* ---------------------------------------------------------------------- */
/* allocate workspace */
/* ---------------------------------------------------------------------- */
getL = Lp && Lj && Lx ;
getU = Up && Ui && Ux ;
if (getL || getU)
{
Wi = (Int *) UMF_malloc (nn, sizeof (Int)) ;
Pattern = (Int *) UMF_malloc (nn, sizeof (Int)) ;
if (!Wi || !Pattern)
{
(void) UMF_free ((void *) Wi) ;
(void) UMF_free ((void *) Pattern) ;
ASSERT (UMF_malloc_count == init_count) ;
DEBUGm4 (("out of memory: get numeric\n")) ;
return (UMFPACK_ERROR_out_of_memory) ;
}
ASSERT (UMF_malloc_count == init_count + 2) ;
}
/* ---------------------------------------------------------------------- */
/* get contents of Numeric */
/* ---------------------------------------------------------------------- */
if (P != (Int *) NULL)
{
Rperm = Numeric->Rperm ;
for (k = 0 ; k < n_row ; k++)
{
P [k] = Rperm [k] ;
}
}
if (Q != (Int *) NULL)
{
Cperm = Numeric->Cperm ;
for (k = 0 ; k < n_col ; k++)
{
Q [k] = Cperm [k] ;
}
}
if (getL)
{
get_L (Lp, Lj, Lx,
#ifdef COMPLEX
Lz,
#endif
Numeric, Pattern, Wi) ;
}
if (getU)
{
get_U (Up, Ui, Ux,
#ifdef COMPLEX
Uz,
#endif
Numeric, Pattern, Wi) ;
}
if (Dx != (double *) NULL)
{
D = Numeric->D ;
#ifdef COMPLEX
if (SPLIT (Dz))
{
for (k = 0 ; k < n_inner ; k++)
{
Dx [k] = REAL_COMPONENT (D [k]) ;
Dz [k] = IMAG_COMPONENT (D [k]) ;
}
}
else
{
for (k = 0 ; k < n_inner ; k++)
{
Dx [2*k ] = REAL_COMPONENT (D [k]) ;
Dx [2*k+1] = IMAG_COMPONENT (D [k]) ;
}
}
#else
{
D = Numeric->D ;
for (k = 0 ; k < n_inner ; k++)
{
Dx [k] = D [k] ;
}
}
#endif
}
/* return the flag stating whether the scale factors are to be multiplied,
* or divided. If do_recip is TRUE, multiply. Otherwise, divided.
* If NRECIPROCAL is defined at compile time, the scale factors are always
* to be used by dividing.
*/
if (p_do_recip != (Int *) NULL)
{
#ifndef NRECIPROCAL
*p_do_recip = Numeric->do_recip ;
#else
*p_do_recip = FALSE ;
#endif
}
if (Rs != (double *) NULL)
{
Rs1 = Numeric->Rs ;
if (Rs1 == (double *) NULL)
{
/* R is the identity matrix. */
for (k = 0 ; k < n_row ; k++)
{
Rs [k] = 1.0 ;
}
}
else
{
for (k = 0 ; k < n_row ; k++)
{
Rs [k] = Rs1 [k] ;
}
}
}
/* ---------------------------------------------------------------------- */
/* free the workspace */
/* ---------------------------------------------------------------------- */
(void) UMF_free ((void *) Wi) ;
(void) UMF_free ((void *) Pattern) ;
ASSERT (UMF_malloc_count == init_count) ;
return (UMFPACK_OK) ;
}
