def _assertNoEmpty2d(*arrays):
    for a in arrays:
        if a.size == 0 and product(a.shape[-2:]) == 0:
            raise LinAlgError("Arrays cannot be empty")

def _assertRankAtLeast2(*arrays):
    for a in arrays:
        if len(a.shape) < 2:
            raise LinAlgError('%d-dimensional array given. Array must be '
                'at least two-dimensional' % len(a.shape))

def _assertNdSquareness(*arrays):
    for a in arrays:
        if max(a.shape[-2:]) != min(a.shape[-2:]):
            raise LinAlgError('Last 2 dimensions of the array must be square')

....

def det(a):
    a = asarray(a)
    _assertNoEmpty2d(a)
    _assertRankAtLeast2(a)
    _assertNdSquareness(a)
    t, result_t = _commonType(a)
    signature = 'D->D' if isComplexType(t) else 'd->d'
    return _umath_linalg.det(a, signature=signature).astype(result_t)

@TYPE@_det(char **args,
npy_intp *dimensions,
npy_intp *steps,
void *NPY_UNUSED(func))
{
fortran_int m;
npy_uint8 *tmp_buff;
size_t matrix_size;
size_t pivot_size;
/* notes:
* matrix will need to be copied always, as factorization in lapack is
* made inplace
* matrix will need to be in column-major order, as expected by lapack
* code (fortran)
* always a square matrix
* need to allocate memory for both, matrix_buffer and pivot buffer
*/
INIT_OUTER_LOOP_2
m = (fortran_int) dimensions[0];
matrix_size = m*m*sizeof(@typ@);
pivot_size = m*sizeof(fortran_int);
tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);
if (tmp_buff)
{
LINEARIZE_DATA_t lin_data;
@typ@ sign;
@basetyp@ logdet;
/* swapped steps to get matrix in FORTRAN order */
init_linearize_data(&lin_data, m, m,
(ptrdiff_t)steps[1],
(ptrdiff_t)steps[0]);
BEGIN_OUTER_LOOP_2
linearize_@TYPE@_matrix(tmp_buff, args[0], &lin_data);
@TYPE@_slogdet_single_element(m,
(void*)tmp_buff,
(fortran_int*)(tmp_buff+matrix_size),
&sign,
&logdet);
*(@typ@ *)args[1] = @TYPE@_det_from_slogdet(sign, logdet);
END_OUTER_LOOP
free(tmp_buff);
}
}
/**end repeat**/