JayKimDevolved/deepseek

c011401 verified 7 months ago

183 kB

	#line 1 "numpy/linalg/umath_linalg.c.src"

	/*
	*****************************************************************************
	This file was autogenerated from a template DO NOT EDIT!!!!
	Changes should be made to the original source (.src) file
	*****************************************************************************
	*/

	#line 1
	/* -- c -- */

	/*
	*****************************************************************************
	INCLUDES
	*****************************************************************************
	*/
	#define NPY_NO_DEPRECATED_API NPY_API_VERSION

	#include "Python.h"
	#include "numpy/arrayobject.h"
	#include "numpy/ufuncobject.h"

	#include "npy_pycompat.h"

	#include "npy_config.h"

	#include <stddef.h>
	#include <stdio.h>
	#include <assert.h>
	#include <math.h>


	static const char* umath_linalg_version_string = "0.1.4";

	/*
	****************************************************************************
	* Debugging support *
	****************************************************************************
	*/
	#define TRACE_TXT(...) do { fprintf (stderr, __VA_ARGS__); } while (0)
	#define STACK_TRACE do {} while (0)
	#define TRACE\
	do { \
	fprintf (stderr, \
	"%s:%d:%s\n", \
	__FILE__, \
	__LINE__, \
	__FUNCTION__); \
	STACK_TRACE; \
	} while (0)

	#if 0
	#include <execinfo.h>
	void
	dbg_stack_trace()
	{
	void *trace[32];
	size_t size;

	size = backtrace(trace, sizeof(trace)/sizeof(trace[0]));
	backtrace_symbols_fd(trace, size, 1);
	}

	#undef STACK_TRACE
	#define STACK_TRACE do { dbg_stack_trace(); } while (0)
	#endif

	/*
	*****************************************************************************
	* BLAS/LAPACK calling macros *
	*****************************************************************************
	*/

	#ifdef NO_APPEND_FORTRAN
	# define FNAME(x) x
	#else
	# define FNAME(x) x##_
	#endif

	typedef struct { float r, i; } f2c_complex;
	typedef struct { double r, i; } f2c_doublecomplex;
	/* typedef long int (L_fp)(); /

	extern int
	FNAME(sgeev)(char jobvl, char jobvr, int *n,
	float a[], int *lda, float wr[], float wi[],
	float vl[], int ldvl, float vr[], int ldvr,
	float work[], int lwork[],
	int *info);
	extern int
	FNAME(dgeev)(char jobvl, char jobvr, int *n,
	double a[], int *lda, double wr[], double wi[],
	double vl[], int ldvl, double vr[], int ldvr,
	double work[], int lwork[],
	int *info);
	extern int
	FNAME(cgeev)(char jobvl, char jobvr, int *n,
	f2c_doublecomplex a[], int *lda,
	f2c_doublecomplex w[],
	f2c_doublecomplex vl[], int *ldvl,
	f2c_doublecomplex vr[], int *ldvr,
	f2c_doublecomplex work[], int *lwork,
	double rwork[],
	int *info);
	extern int
	FNAME(zgeev)(char jobvl, char jobvr, int *n,
	f2c_doublecomplex a[], int *lda,
	f2c_doublecomplex w[],
	f2c_doublecomplex vl[], int *ldvl,
	f2c_doublecomplex vr[], int *ldvr,
	f2c_doublecomplex work[], int *lwork,
	double rwork[],
	int *info);

	extern int
	FNAME(ssyevd)(char jobz, char uplo, int *n,
	float a[], int *lda, float w[], float work[],
	int lwork, int iwork[], int liwork,
	int *info);
	extern int
	FNAME(dsyevd)(char jobz, char uplo, int *n,
	double a[], int *lda, double w[], double work[],
	int lwork, int iwork[], int liwork,
	int *info);
	extern int
	FNAME(cheevd)(char jobz, char uplo, int *n,
	f2c_complex a[], int *lda,
	float w[], f2c_complex work[],
	int lwork, float rwork[], int lrwork, int iwork[],
	int *liwork,
	int *info);
	extern int
	FNAME(zheevd)(char jobz, char uplo, int *n,
	f2c_doublecomplex a[], int *lda,
	double w[], f2c_doublecomplex work[],
	int lwork, double rwork[], int lrwork, int iwork[],
	int *liwork,
	int *info);

	extern int
	FNAME(dgelsd)(int m, int n, int *nrhs,
	double a[], int lda, double b[], int ldb,
	double s[], double rcond, int rank,
	double work[], int *lwork, int iwork[],
	int *info);
	extern int
	FNAME(zgelsd)(int m, int n, int *nrhs,
	f2c_doublecomplex a[], int *lda,
	f2c_doublecomplex b[], int *ldb,
	double s[], double rcond, int rank,
	f2c_doublecomplex work[], int *lwork,
	double rwork[], int iwork[],
	int *info);

	extern int
	FNAME(sgesv)(int n, int nrhs,
	float a[], int *lda,
	int ipiv[],
	float b[], int *ldb,
	int *info);
	extern int
	FNAME(dgesv)(int n, int nrhs,
	double a[], int *lda,
	int ipiv[],
	double b[], int *ldb,
	int *info);
	extern int
	FNAME(cgesv)(int n, int nrhs,
	f2c_complex a[], int *lda,
	int ipiv[],
	f2c_complex b[], int *ldb,
	int *info);
	extern int
	FNAME(zgesv)(int n, int nrhs,
	f2c_doublecomplex a[], int *lda,
	int ipiv[],
	f2c_doublecomplex b[], int *ldb,
	int *info);

	extern int
	FNAME(sgetrf)(int m, int n,
	float a[], int *lda,
	int ipiv[],
	int *info);
	extern int
	FNAME(dgetrf)(int m, int n,
	double a[], int *lda,
	int ipiv[],
	int *info);
	extern int
	FNAME(cgetrf)(int m, int n,
	f2c_complex a[], int *lda,
	int ipiv[],
	int *info);
	extern int
	FNAME(zgetrf)(int m, int n,
	f2c_doublecomplex a[], int *lda,
	int ipiv[],
	int *info);

	extern int
	FNAME(spotrf)(char uplo, int n,
	float a[], int *lda,
	int *info);
	extern int
	FNAME(dpotrf)(char uplo, int n,
	double a[], int *lda,
	int *info);
	extern int
	FNAME(cpotrf)(char uplo, int n,
	f2c_complex a[], int *lda,
	int *info);
	extern int
	FNAME(zpotrf)(char uplo, int n,
	f2c_doublecomplex a[], int *lda,
	int *info);

	extern int
	FNAME(sgesdd)(char jobz, int m, int *n,
	float a[], int *lda, float s[], float u[],
	int ldu, float vt[], int ldvt, float work[],
	int lwork, int iwork[], int info);
	extern int
	FNAME(dgesdd)(char jobz, int m, int *n,
	double a[], int *lda, double s[], double u[],
	int ldu, double vt[], int ldvt, double work[],
	int lwork, int iwork[], int info);
	extern int
	FNAME(cgesdd)(char jobz, int m, int *n,
	f2c_complex a[], int *lda,
	float s[], f2c_complex u[], int *ldu,
	f2c_complex vt[], int *ldvt,
	f2c_complex work[], int *lwork,
	float rwork[], int iwork[], int *info);
	extern int
	FNAME(zgesdd)(char jobz, int m, int *n,
	f2c_doublecomplex a[], int *lda,
	double s[], f2c_doublecomplex u[], int *ldu,
	f2c_doublecomplex vt[], int *ldvt,
	f2c_doublecomplex work[], int *lwork,
	double rwork[], int iwork[], int *info);

	extern int
	FNAME(spotrs)(char uplo, int n, int *nrhs,
	float a[], int *lda,
	float b[], int *ldb,
	int *info);
	extern int
	FNAME(dpotrs)(char uplo, int n, int *nrhs,
	double a[], int *lda,
	double b[], int *ldb,
	int *info);
	extern int
	FNAME(cpotrs)(char uplo, int n, int *nrhs,
	f2c_complex a[], int *lda,
	f2c_complex b[], int *ldb,
	int *info);
	extern int
	FNAME(zpotrs)(char uplo, int n, int *nrhs,
	f2c_doublecomplex a[], int *lda,
	f2c_doublecomplex b[], int *ldb,
	int *info);

	extern int
	FNAME(spotri)(char uplo, int n,
	float a[], int *lda,
	int *info);
	extern int
	FNAME(dpotri)(char uplo, int n,
	double a[], int *lda,
	int *info);
	extern int
	FNAME(cpotri)(char uplo, int n,
	f2c_complex a[], int *lda,
	int *info);
	extern int
	FNAME(zpotri)(char uplo, int n,
	f2c_doublecomplex a[], int *lda,
	int *info);

	extern int
	FNAME(scopy)(int *n,
	float sx, int incx,
	float sy, int incy);
	extern int
	FNAME(dcopy)(int *n,
	double sx, int incx,
	double sy, int incy);
	extern int
	FNAME(ccopy)(int *n,
	f2c_complex sx, int incx,
	f2c_complex sy, int incy);
	extern int
	FNAME(zcopy)(int *n,
	f2c_doublecomplex sx, int incx,
	f2c_doublecomplex sy, int incy);

	extern float
	FNAME(sdot)(int *n,
	float sx, int incx,
	float sy, int incy);
	extern double
	FNAME(ddot)(int *n,
	double sx, int incx,
	double sy, int incy);
	extern f2c_complex
	FNAME(cdotu)(int *n,
	f2c_complex sx, int incx,
	f2c_complex sy, int incy);
	extern f2c_doublecomplex
	FNAME(zdotu)(int *n,
	f2c_doublecomplex sx, int incx,
	f2c_doublecomplex sy, int incy);
	extern f2c_complex
	FNAME(cdotc)(int *n,
	f2c_complex sx, int incx,
	f2c_complex sy, int incy);
	extern f2c_doublecomplex
	FNAME(zdotc)(int *n,
	f2c_doublecomplex sx, int incx,
	f2c_doublecomplex sy, int incy);

	extern int
	FNAME(sgemm)(char transa, char transb,
	int m, int n, int *k,
	float *alpha,
	float a, int lda,
	float b, int ldb,
	float *beta,
	float c, int ldc);
	extern int
	FNAME(dgemm)(char transa, char transb,
	int m, int n, int *k,
	double *alpha,
	double a, int lda,
	double b, int ldb,
	double *beta,
	double c, int ldc);
	extern int
	FNAME(cgemm)(char transa, char transb,
	int m, int n, int *k,
	f2c_complex *alpha,
	f2c_complex a, int lda,
	f2c_complex b, int ldb,
	f2c_complex *beta,
	f2c_complex c, int ldc);
	extern int
	FNAME(zgemm)(char transa, char transb,
	int m, int n, int *k,
	f2c_doublecomplex *alpha,
	f2c_doublecomplex a, int lda,
	f2c_doublecomplex b, int ldb,
	f2c_doublecomplex *beta,
	f2c_doublecomplex c, int ldc);


	#define LAPACK_T(FUNC) \
	TRACE_TXT("Calling LAPACK ( " # FUNC " )\n"); \
	FNAME(FUNC)

	#define BLAS(FUNC) \
	FNAME(FUNC)

	#define LAPACK(FUNC) \
	FNAME(FUNC)

	typedef int fortran_int;
	typedef float fortran_real;
	typedef double fortran_doublereal;
	typedef f2c_complex fortran_complex;
	typedef f2c_doublecomplex fortran_doublecomplex;


	/*
	*****************************************************************************
	Some handy functions
	*****************************************************************************
	*/

	static inline void *
	offset_ptr(void* ptr, ptrdiff_t offset)
	{
	return (void)((npy_uint8)ptr + offset);
	}

	static inline int
	get_fp_invalid_and_clear(void)
	{
	int status;
	status = npy_clear_floatstatus();
	return !!(status & NPY_FPE_INVALID);
	}

	static inline void
	set_fp_invalid_or_clear(int error_occurred)
	{
	if (error_occurred) {
	npy_set_floatstatus_invalid();
	}
	else {
	npy_clear_floatstatus();
	}
	}

	/*
	*****************************************************************************
	Some handy constants
	*****************************************************************************
	*/

	#define UMATH_LINALG_MODULE_NAME "_umath_linalg"

	typedef union {
	fortran_complex f;
	npy_cfloat npy;
	float array[2];
	} COMPLEX_t;

	typedef union {
	fortran_doublecomplex f;
	npy_cdouble npy;
	double array[2];
	} DOUBLECOMPLEX_t;

	static float s_one;
	static float s_zero;
	static float s_minus_one;
	static float s_ninf;
	static float s_nan;
	static double d_one;
	static double d_zero;
	static double d_minus_one;
	static double d_ninf;
	static double d_nan;
	static COMPLEX_t c_one;
	static COMPLEX_t c_zero;
	static COMPLEX_t c_minus_one;
	static COMPLEX_t c_ninf;
	static COMPLEX_t c_nan;
	static DOUBLECOMPLEX_t z_one;
	static DOUBLECOMPLEX_t z_zero;
	static DOUBLECOMPLEX_t z_minus_one;
	static DOUBLECOMPLEX_t z_ninf;
	static DOUBLECOMPLEX_t z_nan;

	static void init_constants(void)
	{
	/*
	this is needed as NPY_INFINITY and NPY_NAN macros
	can't be used as initializers. I prefer to just set
	all the constants the same way.
	*/
	s_one = 1.0f;
	s_zero = 0.0f;
	s_minus_one = -1.0f;
	s_ninf = -NPY_INFINITYF;
	s_nan = NPY_NANF;

	d_one = 1.0;
	d_zero = 0.0;
	d_minus_one = -1.0;
	d_ninf = -NPY_INFINITY;
	d_nan = NPY_NAN;

	c_one.array[0] = 1.0f;
	c_one.array[1] = 0.0f;
	c_zero.array[0] = 0.0f;
	c_zero.array[1] = 0.0f;
	c_minus_one.array[0] = -1.0f;
	c_minus_one.array[1] = 0.0f;
	c_ninf.array[0] = -NPY_INFINITYF;
	c_ninf.array[1] = 0.0f;
	c_nan.array[0] = NPY_NANF;
	c_nan.array[1] = NPY_NANF;

	z_one.array[0] = 1.0;
	z_one.array[1] = 0.0;
	z_zero.array[0] = 0.0;
	z_zero.array[1] = 0.0;
	z_minus_one.array[0] = -1.0;
	z_minus_one.array[1] = 0.0;
	z_ninf.array[0] = -NPY_INFINITY;
	z_ninf.array[1] = 0.0;
	z_nan.array[0] = NPY_NAN;
	z_nan.array[1] = NPY_NAN;
	}

	/*
	*****************************************************************************
	Structs used for data rearrangement
	*****************************************************************************
	*/


	/* this struct contains information about how to linearize in a local buffer
	a matrix so that it can be used by blas functions.
	All strides are specified in number of elements (similar to what blas
	expects)

	dst_row_strides: number of elements between different row. Matrix is
	considered row-major
	dst_column_strides: number of elements between differnt columns in the
	destination buffer
	rows: number of rows of the matrix
	columns: number of columns of the matrix
	src_row_strides: strides needed to access the next row in the source matrix
	src_column_strides: strides needed to access the next column in the source
	matrix
	*/
	typedef struct linearize_data_struct
	{
	size_t rows;
	size_t columns;
	ptrdiff_t row_strides;
	ptrdiff_t column_strides;
	} LINEARIZE_DATA_t;

	static inline void
	init_linearize_data(LINEARIZE_DATA_t *lin_data,
	int rows,
	int columns,
	ptrdiff_t row_strides,
	ptrdiff_t column_strides)
	{
	lin_data->rows = rows;
	lin_data->columns = columns;
	lin_data->row_strides = row_strides;
	lin_data->column_strides = column_strides;
	}

	static inline void
	dump_ufunc_object(PyUFuncObject* ufunc)
	{
	TRACE_TXT("\n\n%s '%s' (%d input(s), %d output(s), %d specialization(s).\n",
	ufunc->core_enabled? "generalized ufunc" : "scalar ufunc",
	ufunc->name, ufunc->nin, ufunc->nout, ufunc->ntypes);
	if (ufunc->core_enabled) {
	int arg;
	int dim;
	TRACE_TXT("\t%s (%d dimension(s) detected).\n",
	ufunc->core_signature, ufunc->core_num_dim_ix);

	for (arg = 0; arg < ufunc->nargs; arg++){
	int * arg_dim_ix = ufunc->core_dim_ixs + ufunc->core_offsets[arg];
	TRACE_TXT("\t\targ %d (%s) has %d dimension(s): (",
	arg, arg < ufunc->nin? "INPUT" : "OUTPUT",
	ufunc->core_num_dims[arg]);
	for (dim = 0; dim < ufunc->core_num_dims[arg]; dim ++) {
	TRACE_TXT(" %d", arg_dim_ix[dim]);
	}
	TRACE_TXT(" )\n");
	}
	}
	}

	static inline void
	dump_linearize_data(const char* name, const LINEARIZE_DATA_t* params)
	{
	TRACE_TXT("\n\t%s rows: %zd columns: %zd"\
	"\n\t\trow_strides: %td column_strides: %td"\
	"\n", name, params->rows, params->columns,
	params->row_strides, params->column_strides);
	}


	static inline float
	FLOAT_add(float op1, float op2)
	{
	return op1 + op2;
	}

	static inline double
	DOUBLE_add(double op1, double op2)
	{
	return op1 + op2;
	}

	static inline COMPLEX_t
	CFLOAT_add(COMPLEX_t op1, COMPLEX_t op2)
	{
	COMPLEX_t result;
	result.array[0] = op1.array[0] + op2.array[0];
	result.array[1] = op1.array[1] + op2.array[1];

	return result;
	}

	static inline DOUBLECOMPLEX_t
	CDOUBLE_add(DOUBLECOMPLEX_t op1, DOUBLECOMPLEX_t op2)
	{
	DOUBLECOMPLEX_t result;
	result.array[0] = op1.array[0] + op2.array[0];
	result.array[1] = op1.array[1] + op2.array[1];

	return result;
	}

	static inline float
	FLOAT_mul(float op1, float op2)
	{
	return op1*op2;
	}

	static inline double
	DOUBLE_mul(double op1, double op2)
	{
	return op1*op2;
	}


	static inline COMPLEX_t
	CFLOAT_mul(COMPLEX_t op1, COMPLEX_t op2)
	{
	COMPLEX_t result;
	result.array[0] = op1.array[0]op2.array[0] - op1.array[1]op2.array[1];
	result.array[1] = op1.array[1]op2.array[0] + op1.array[0]op2.array[1];

	return result;
	}

	static inline DOUBLECOMPLEX_t
	CDOUBLE_mul(DOUBLECOMPLEX_t op1, DOUBLECOMPLEX_t op2)
	{
	DOUBLECOMPLEX_t result;
	result.array[0] = op1.array[0]op2.array[0] - op1.array[1]op2.array[1];
	result.array[1] = op1.array[1]op2.array[0] + op1.array[0]op2.array[1];

	return result;
	}

	static inline float
	FLOAT_mulc(float op1, float op2)
	{
	return op1*op2;
	}

	static inline double
	DOUBLE_mulc(float op1, float op2)
	{
	return op1*op2;
	}

	static inline COMPLEX_t
	CFLOAT_mulc(COMPLEX_t op1, COMPLEX_t op2)
	{
	COMPLEX_t result;
	result.array[0] = op1.array[0]op2.array[0] + op1.array[1]op2.array[1];
	result.array[1] = op1.array[0]op2.array[1] - op1.array[1]op2.array[0];

	return result;
	}

	static inline DOUBLECOMPLEX_t
	CDOUBLE_mulc(DOUBLECOMPLEX_t op1, DOUBLECOMPLEX_t op2)
	{
	DOUBLECOMPLEX_t result;
	result.array[0] = op1.array[0]op2.array[0] + op1.array[1]op2.array[1];
	result.array[1] = op1.array[0]op2.array[1] - op1.array[1]op2.array[0];

	return result;
	}

	static inline void
	print_FLOAT(npy_float s)
	{
	TRACE_TXT(" %8.4f", s);
	}
	static inline void
	print_DOUBLE(npy_double d)
	{
	TRACE_TXT(" %10.6f", d);
	}
	static inline void
	print_CFLOAT(npy_cfloat c)
	{
	float* c_parts = (float*)&c;
	TRACE_TXT("(%8.4f, %8.4fj)", c_parts[0], c_parts[1]);
	}
	static inline void
	print_CDOUBLE(npy_cdouble z)
	{
	double* z_parts = (double*)&z;
	TRACE_TXT("(%8.4f, %8.4fj)", z_parts[0], z_parts[1]);
	}

	#line 681
	static inline void
	dump_FLOAT_matrix(const char* name,
	size_t rows, size_t columns,
	const npy_float* ptr)
	{
	size_t i,j;

	TRACE_TXT("\n%s %p (%zd, %zd)\n", name, ptr, rows, columns);
	for (i=0; i<rows; i++)
	{
	TRACE_TXT("\| ");
	for (j=0; j<columns; j++)
	{
	print_FLOAT(ptr[j*rows + i]);
	TRACE_TXT(", ");
	}
	TRACE_TXT(" \|\n");
	}
	}

	#line 681
	static inline void
	dump_DOUBLE_matrix(const char* name,
	size_t rows, size_t columns,
	const npy_double* ptr)
	{
	size_t i,j;

	TRACE_TXT("\n%s %p (%zd, %zd)\n", name, ptr, rows, columns);
	for (i=0; i<rows; i++)
	{
	TRACE_TXT("\| ");
	for (j=0; j<columns; j++)
	{
	print_DOUBLE(ptr[j*rows + i]);
	TRACE_TXT(", ");
	}
	TRACE_TXT(" \|\n");
	}
	}

	#line 681
	static inline void
	dump_CFLOAT_matrix(const char* name,
	size_t rows, size_t columns,
	const npy_cfloat* ptr)
	{
	size_t i,j;

	TRACE_TXT("\n%s %p (%zd, %zd)\n", name, ptr, rows, columns);
	for (i=0; i<rows; i++)
	{
	TRACE_TXT("\| ");
	for (j=0; j<columns; j++)
	{
	print_CFLOAT(ptr[j*rows + i]);
	TRACE_TXT(", ");
	}
	TRACE_TXT(" \|\n");
	}
	}

	#line 681
	static inline void
	dump_CDOUBLE_matrix(const char* name,
	size_t rows, size_t columns,
	const npy_cdouble* ptr)
	{
	size_t i,j;

	TRACE_TXT("\n%s %p (%zd, %zd)\n", name, ptr, rows, columns);
	for (i=0; i<rows; i++)
	{
	TRACE_TXT("\| ");
	for (j=0; j<columns; j++)
	{
	print_CDOUBLE(ptr[j*rows + i]);
	TRACE_TXT(", ");
	}
	TRACE_TXT(" \|\n");
	}
	}



	/*
	*****************************************************************************
	Basics
	*****************************************************************************
	*/

	#define INIT_OUTER_LOOP_1 \
	npy_intp dN = *dimensions++;\
	npy_intp N_;\
	npy_intp s0 = *steps++;

	#define INIT_OUTER_LOOP_2 \
	INIT_OUTER_LOOP_1\
	npy_intp s1 = *steps++;

	#define INIT_OUTER_LOOP_3 \
	INIT_OUTER_LOOP_2\
	npy_intp s2 = *steps++;

	#define INIT_OUTER_LOOP_4 \
	INIT_OUTER_LOOP_3\
	npy_intp s3 = *steps++;

	#define INIT_OUTER_LOOP_5 \
	INIT_OUTER_LOOP_4\
	npy_intp s4 = *steps++;

	#define INIT_OUTER_LOOP_6 \
	INIT_OUTER_LOOP_5\
	npy_intp s5 = *steps++;

	#define BEGIN_OUTER_LOOP_2 \
	for (N_ = 0;\
	N_ < dN;\
	N_++, args[0] += s0,\
	args[1] += s1) {

	#define BEGIN_OUTER_LOOP_3 \
	for (N_ = 0;\
	N_ < dN;\
	N_++, args[0] += s0,\
	args[1] += s1,\
	args[2] += s2) {

	#define BEGIN_OUTER_LOOP_4 \
	for (N_ = 0;\
	N_ < dN;\
	N_++, args[0] += s0,\
	args[1] += s1,\
	args[2] += s2,\
	args[3] += s3) {

	#define BEGIN_OUTER_LOOP_5 \
	for (N_ = 0;\
	N_ < dN;\
	N_++, args[0] += s0,\
	args[1] += s1,\
	args[2] += s2,\
	args[3] += s3,\
	args[4] += s4) {

	#define BEGIN_OUTER_LOOP_6 \
	for (N_ = 0;\
	N_ < dN;\
	N_++, args[0] += s0,\
	args[1] += s1,\
	args[2] += s2,\
	args[3] += s3,\
	args[4] += s4,\
	args[5] += s5) {

	#define END_OUTER_LOOP }

	static inline void
	update_pointers(npy_uint8** bases, ptrdiff_t* offsets, size_t count)
	{
	size_t i;
	for (i=0; i < count; ++i) {
	bases[i] += offsets[i];
	}
	}


	/* disable -Wmaybe-uninitialized as there is some code that generate false
	positives with this warning
	*/
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

	/*
	*****************************************************************************
	HELPER FUNCS
	*****************************************************************************
	*/

	/* rearranging of 2D matrices using blas */

	#line 806
	static inline void *
	linearize_FLOAT_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	float src = (float ) src_in;
	float dst = (float ) dst_in;

	if (dst) {
	int i, j;
	float* rv = dst;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(float));
	fortran_int one = 1;
	for (i=0; i< data->rows; i++) {
	if (column_strides > 0) {
	FNAME(scopy)(&columns,
	(void*)src, &column_strides,
	(void*)dst, &one);
	}
	else if (column_strides < 0) {
	FNAME(scopy)(&columns,
	(void)((float)src + (columns-1)*column_strides),
	&column_strides,
	(void*)dst, &one);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	for (j = 0; j < columns; ++j) {
	memcpy((float)dst + j, (float)src, sizeof(float));
	}
	}
	src += data->row_strides/sizeof(float);
	dst += data->columns;
	}
	return rv;
	} else {
	return src;
	}
	}

	static inline void *
	delinearize_FLOAT_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	float src = (float ) src_in;
	float dst = (float ) dst_in;

	if (src) {
	int i;
	float *rv = src;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(float));
	fortran_int one = 1;
	for (i=0; i < data->rows; i++) {
	if (column_strides > 0) {
	FNAME(scopy)(&columns,
	(void*)src, &one,
	(void*)dst, &column_strides);
	}
	else if (column_strides < 0) {
	FNAME(scopy)(&columns,
	(void*)src, &one,
	(void)((float)dst + (columns-1)*column_strides),
	&column_strides);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	if (columns > 0) {
	memcpy((float)dst, (float)src + (columns-1), sizeof(float));
	}
	}
	src += data->columns;
	dst += data->row_strides/sizeof(float);
	}

	return rv;
	} else {
	return src;
	}
	}

	static inline void
	nan_FLOAT_matrix(void dst_in, const LINEARIZE_DATA_t data)
	{
	float dst = (float ) dst_in;

	int i,j;
	for (i=0; i < data->rows; i++) {
	float *cp = dst;
	ptrdiff_t cs = data->column_strides/sizeof(float);
	for (j=0; j< data->columns; ++j) {
	*cp = s_nan;
	cp += cs;
	}
	dst += data->row_strides/sizeof(float);
	}
	}


	#line 806
	static inline void *
	linearize_DOUBLE_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	double src = (double ) src_in;
	double dst = (double ) dst_in;

	if (dst) {
	int i, j;
	double* rv = dst;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(double));
	fortran_int one = 1;
	for (i=0; i< data->rows; i++) {
	if (column_strides > 0) {
	FNAME(dcopy)(&columns,
	(void*)src, &column_strides,
	(void*)dst, &one);
	}
	else if (column_strides < 0) {
	FNAME(dcopy)(&columns,
	(void)((double)src + (columns-1)*column_strides),
	&column_strides,
	(void*)dst, &one);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	for (j = 0; j < columns; ++j) {
	memcpy((double)dst + j, (double)src, sizeof(double));
	}
	}
	src += data->row_strides/sizeof(double);
	dst += data->columns;
	}
	return rv;
	} else {
	return src;
	}
	}

	static inline void *
	delinearize_DOUBLE_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	double src = (double ) src_in;
	double dst = (double ) dst_in;

	if (src) {
	int i;
	double *rv = src;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(double));
	fortran_int one = 1;
	for (i=0; i < data->rows; i++) {
	if (column_strides > 0) {
	FNAME(dcopy)(&columns,
	(void*)src, &one,
	(void*)dst, &column_strides);
	}
	else if (column_strides < 0) {
	FNAME(dcopy)(&columns,
	(void*)src, &one,
	(void)((double)dst + (columns-1)*column_strides),
	&column_strides);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	if (columns > 0) {
	memcpy((double)dst, (double)src + (columns-1), sizeof(double));
	}
	}
	src += data->columns;
	dst += data->row_strides/sizeof(double);
	}

	return rv;
	} else {
	return src;
	}
	}

	static inline void
	nan_DOUBLE_matrix(void dst_in, const LINEARIZE_DATA_t data)
	{
	double dst = (double ) dst_in;

	int i,j;
	for (i=0; i < data->rows; i++) {
	double *cp = dst;
	ptrdiff_t cs = data->column_strides/sizeof(double);
	for (j=0; j< data->columns; ++j) {
	*cp = d_nan;
	cp += cs;
	}
	dst += data->row_strides/sizeof(double);
	}
	}


	#line 806
	static inline void *
	linearize_CFLOAT_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	COMPLEX_t src = (COMPLEX_t ) src_in;
	COMPLEX_t dst = (COMPLEX_t ) dst_in;

	if (dst) {
	int i, j;
	COMPLEX_t* rv = dst;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(COMPLEX_t));
	fortran_int one = 1;
	for (i=0; i< data->rows; i++) {
	if (column_strides > 0) {
	FNAME(ccopy)(&columns,
	(void*)src, &column_strides,
	(void*)dst, &one);
	}
	else if (column_strides < 0) {
	FNAME(ccopy)(&columns,
	(void)((COMPLEX_t)src + (columns-1)*column_strides),
	&column_strides,
	(void*)dst, &one);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	for (j = 0; j < columns; ++j) {
	memcpy((COMPLEX_t)dst + j, (COMPLEX_t)src, sizeof(COMPLEX_t));
	}
	}
	src += data->row_strides/sizeof(COMPLEX_t);
	dst += data->columns;
	}
	return rv;
	} else {
	return src;
	}
	}

	static inline void *
	delinearize_CFLOAT_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	COMPLEX_t src = (COMPLEX_t ) src_in;
	COMPLEX_t dst = (COMPLEX_t ) dst_in;

	if (src) {
	int i;
	COMPLEX_t *rv = src;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(COMPLEX_t));
	fortran_int one = 1;
	for (i=0; i < data->rows; i++) {
	if (column_strides > 0) {
	FNAME(ccopy)(&columns,
	(void*)src, &one,
	(void*)dst, &column_strides);
	}
	else if (column_strides < 0) {
	FNAME(ccopy)(&columns,
	(void*)src, &one,
	(void)((COMPLEX_t)dst + (columns-1)*column_strides),
	&column_strides);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	if (columns > 0) {
	memcpy((COMPLEX_t)dst, (COMPLEX_t)src + (columns-1), sizeof(COMPLEX_t));
	}
	}
	src += data->columns;
	dst += data->row_strides/sizeof(COMPLEX_t);
	}

	return rv;
	} else {
	return src;
	}
	}

	static inline void
	nan_CFLOAT_matrix(void dst_in, const LINEARIZE_DATA_t data)
	{
	COMPLEX_t dst = (COMPLEX_t ) dst_in;

	int i,j;
	for (i=0; i < data->rows; i++) {
	COMPLEX_t *cp = dst;
	ptrdiff_t cs = data->column_strides/sizeof(COMPLEX_t);
	for (j=0; j< data->columns; ++j) {
	*cp = c_nan;
	cp += cs;
	}
	dst += data->row_strides/sizeof(COMPLEX_t);
	}
	}


	#line 806
	static inline void *
	linearize_CDOUBLE_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	DOUBLECOMPLEX_t src = (DOUBLECOMPLEX_t ) src_in;
	DOUBLECOMPLEX_t dst = (DOUBLECOMPLEX_t ) dst_in;

	if (dst) {
	int i, j;
	DOUBLECOMPLEX_t* rv = dst;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(DOUBLECOMPLEX_t));
	fortran_int one = 1;
	for (i=0; i< data->rows; i++) {
	if (column_strides > 0) {
	FNAME(zcopy)(&columns,
	(void*)src, &column_strides,
	(void*)dst, &one);
	}
	else if (column_strides < 0) {
	FNAME(zcopy)(&columns,
	(void)((DOUBLECOMPLEX_t)src + (columns-1)*column_strides),
	&column_strides,
	(void*)dst, &one);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	for (j = 0; j < columns; ++j) {
	memcpy((DOUBLECOMPLEX_t)dst + j, (DOUBLECOMPLEX_t)src, sizeof(DOUBLECOMPLEX_t));
	}
	}
	src += data->row_strides/sizeof(DOUBLECOMPLEX_t);
	dst += data->columns;
	}
	return rv;
	} else {
	return src;
	}
	}

	static inline void *
	delinearize_CDOUBLE_matrix(void *dst_in,
	void *src_in,
	const LINEARIZE_DATA_t* data)
	{
	DOUBLECOMPLEX_t src = (DOUBLECOMPLEX_t ) src_in;
	DOUBLECOMPLEX_t dst = (DOUBLECOMPLEX_t ) dst_in;

	if (src) {
	int i;
	DOUBLECOMPLEX_t *rv = src;
	fortran_int columns = (fortran_int)data->columns;
	fortran_int column_strides =
	(fortran_int)(data->column_strides/sizeof(DOUBLECOMPLEX_t));
	fortran_int one = 1;
	for (i=0; i < data->rows; i++) {
	if (column_strides > 0) {
	FNAME(zcopy)(&columns,
	(void*)src, &one,
	(void*)dst, &column_strides);
	}
	else if (column_strides < 0) {
	FNAME(zcopy)(&columns,
	(void*)src, &one,
	(void)((DOUBLECOMPLEX_t)dst + (columns-1)*column_strides),
	&column_strides);
	}
	else {
	/*
	* Zero stride has undefined behavior in some BLAS
	* implementations (e.g. OSX Accelerate), so do it
	* manually
	*/
	if (columns > 0) {
	memcpy((DOUBLECOMPLEX_t)dst, (DOUBLECOMPLEX_t)src + (columns-1), sizeof(DOUBLECOMPLEX_t));
	}
	}
	src += data->columns;
	dst += data->row_strides/sizeof(DOUBLECOMPLEX_t);
	}

	return rv;
	} else {
	return src;
	}
	}

	static inline void
	nan_CDOUBLE_matrix(void dst_in, const LINEARIZE_DATA_t data)
	{
	DOUBLECOMPLEX_t dst = (DOUBLECOMPLEX_t ) dst_in;

	int i,j;
	for (i=0; i < data->rows; i++) {
	DOUBLECOMPLEX_t *cp = dst;
	ptrdiff_t cs = data->column_strides/sizeof(DOUBLECOMPLEX_t);
	for (j=0; j< data->columns; ++j) {
	*cp = z_nan;
	cp += cs;
	}
	dst += data->row_strides/sizeof(DOUBLECOMPLEX_t);
	}
	}



	/* identity square matrix generation */
	#line 924
	static inline void
	identity_FLOAT_matrix(void *ptr, size_t n)
	{
	size_t i;
	float matrix = (float) ptr;
	/* in IEEE floating point, zeroes are represented as bitwise 0 */
	memset(matrix, 0, nnsizeof(float));

	for (i = 0; i < n; ++i)
	{
	*matrix = s_one;
	matrix += n+1;
	}
	}

	#line 924
	static inline void
	identity_DOUBLE_matrix(void *ptr, size_t n)
	{
	size_t i;
	double matrix = (double) ptr;
	/* in IEEE floating point, zeroes are represented as bitwise 0 */
	memset(matrix, 0, nnsizeof(double));

	for (i = 0; i < n; ++i)
	{
	*matrix = d_one;
	matrix += n+1;
	}
	}

	#line 924
	static inline void
	identity_CFLOAT_matrix(void *ptr, size_t n)
	{
	size_t i;
	COMPLEX_t matrix = (COMPLEX_t) ptr;
	/* in IEEE floating point, zeroes are represented as bitwise 0 */
	memset(matrix, 0, nnsizeof(COMPLEX_t));

	for (i = 0; i < n; ++i)
	{
	*matrix = c_one;
	matrix += n+1;
	}
	}

	#line 924
	static inline void
	identity_CDOUBLE_matrix(void *ptr, size_t n)
	{
	size_t i;
	DOUBLECOMPLEX_t matrix = (DOUBLECOMPLEX_t) ptr;
	/* in IEEE floating point, zeroes are represented as bitwise 0 */
	memset(matrix, 0, nnsizeof(DOUBLECOMPLEX_t));

	for (i = 0; i < n; ++i)
	{
	*matrix = z_one;
	matrix += n+1;
	}
	}


	/* lower/upper triangular matrix using blas (in place) */
	#line 947

	static inline void
	triu_FLOAT_matrix(void *ptr, size_t n)
	{
	size_t i,j;
	float matrix = (float)ptr;
	matrix += n;
	for (i=1; i < n; ++i) {
	for (j=0; j<i; ++j) {
	matrix[j] = s_zero;
	}
	matrix += n;
	}
	}

	#line 947

	static inline void
	triu_DOUBLE_matrix(void *ptr, size_t n)
	{
	size_t i,j;
	double matrix = (double)ptr;
	matrix += n;
	for (i=1; i < n; ++i) {
	for (j=0; j<i; ++j) {
	matrix[j] = d_zero;
	}
	matrix += n;
	}
	}

	#line 947

	static inline void
	triu_CFLOAT_matrix(void *ptr, size_t n)
	{
	size_t i,j;
	COMPLEX_t matrix = (COMPLEX_t)ptr;
	matrix += n;
	for (i=1; i < n; ++i) {
	for (j=0; j<i; ++j) {
	matrix[j] = c_zero;
	}
	matrix += n;
	}
	}

	#line 947

	static inline void
	triu_CDOUBLE_matrix(void *ptr, size_t n)
	{
	size_t i,j;
	DOUBLECOMPLEX_t matrix = (DOUBLECOMPLEX_t)ptr;
	matrix += n;
	for (i=1; i < n; ++i) {
	for (j=0; j<i; ++j) {
	matrix[j] = z_zero;
	}
	matrix += n;
	}
	}



	/* -------------------------------------------------------------------------- */
	/* Determinants */

	#line 974

	static inline void
	FLOAT_slogdet_from_factored_diagonal(npy_float* src,
	fortran_int m,
	npy_float *sign,
	npy_float *logdet)
	{
	npy_float acc_sign = *sign;
	npy_float acc_logdet = 0.0f;
	int i;
	for (i = 0; i < m; i++) {
	npy_float abs_element = *src;
	if (abs_element < 0.0f) {
	acc_sign = -acc_sign;
	abs_element = -abs_element;
	}

	acc_logdet += npy_logf(abs_element);
	src += m+1;
	}

	*sign = acc_sign;
	*logdet = acc_logdet;
	}

	static inline npy_float
	FLOAT_det_from_slogdet(npy_float sign, npy_float logdet)
	{
	npy_float result = sign * npy_expf(logdet);
	return result;
	}


	#line 974

	static inline void
	DOUBLE_slogdet_from_factored_diagonal(npy_double* src,
	fortran_int m,
	npy_double *sign,
	npy_double *logdet)
	{
	npy_double acc_sign = *sign;
	npy_double acc_logdet = 0.0;
	int i;
	for (i = 0; i < m; i++) {
	npy_double abs_element = *src;
	if (abs_element < 0.0) {
	acc_sign = -acc_sign;
	abs_element = -abs_element;
	}

	acc_logdet += npy_log(abs_element);
	src += m+1;
	}

	*sign = acc_sign;
	*logdet = acc_logdet;
	}

	static inline npy_double
	DOUBLE_det_from_slogdet(npy_double sign, npy_double logdet)
	{
	npy_double result = sign * npy_exp(logdet);
	return result;
	}




	#line 1018
	#define RE(COMPLEX) (((npy_float*)(&COMPLEX))[0])
	#define IM(COMPLEX) (((npy_float*)(&COMPLEX))[1])

	static inline npy_cfloat
	CFLOAT_mult(npy_cfloat op1, npy_cfloat op2)
	{
	npy_cfloat rv;

	RE(rv) = RE(op1)RE(op2) - IM(op1)IM(op2);
	IM(rv) = RE(op1)IM(op2) + IM(op1)RE(op2);

	return rv;
	}


	static inline void
	CFLOAT_slogdet_from_factored_diagonal(npy_cfloat* src,
	fortran_int m,
	npy_cfloat *sign,
	npy_float *logdet)
	{
	int i;
	npy_cfloat sign_acc = *sign;
	npy_float logdet_acc = 0.0f;

	for (i = 0; i < m; i++)
	{
	npy_float abs_element = npy_cabsf(*src);
	npy_cfloat sign_element;
	RE(sign_element) = RE(*src) / abs_element;
	IM(sign_element) = IM(*src) / abs_element;

	sign_acc = CFLOAT_mult(sign_acc, sign_element);
	logdet_acc += npy_logf(abs_element);
	src += m + 1;
	}

	*sign = sign_acc;
	*logdet = logdet_acc;
	}

	static inline npy_cfloat
	CFLOAT_det_from_slogdet(npy_cfloat sign, npy_float logdet)
	{
	npy_cfloat tmp;
	RE(tmp) = npy_expf(logdet);
	IM(tmp) = 0.0f;
	return CFLOAT_mult(sign, tmp);
	}
	#undef RE
	#undef IM

	#line 1018
	#define RE(COMPLEX) (((npy_double*)(&COMPLEX))[0])
	#define IM(COMPLEX) (((npy_double*)(&COMPLEX))[1])

	static inline npy_cdouble
	CDOUBLE_mult(npy_cdouble op1, npy_cdouble op2)
	{
	npy_cdouble rv;

	RE(rv) = RE(op1)RE(op2) - IM(op1)IM(op2);
	IM(rv) = RE(op1)IM(op2) + IM(op1)RE(op2);

	return rv;
	}


	static inline void
	CDOUBLE_slogdet_from_factored_diagonal(npy_cdouble* src,
	fortran_int m,
	npy_cdouble *sign,
	npy_double *logdet)
	{
	int i;
	npy_cdouble sign_acc = *sign;
	npy_double logdet_acc = 0.0;

	for (i = 0; i < m; i++)
	{
	npy_double abs_element = npy_cabs(*src);
	npy_cdouble sign_element;
	RE(sign_element) = RE(*src) / abs_element;
	IM(sign_element) = IM(*src) / abs_element;

	sign_acc = CDOUBLE_mult(sign_acc, sign_element);
	logdet_acc += npy_log(abs_element);
	src += m + 1;
	}

	*sign = sign_acc;
	*logdet = logdet_acc;
	}

	static inline npy_cdouble
	CDOUBLE_det_from_slogdet(npy_cdouble sign, npy_double logdet)
	{
	npy_cdouble tmp;
	RE(tmp) = npy_exp(logdet);
	IM(tmp) = 0.0;
	return CDOUBLE_mult(sign, tmp);
	}
	#undef RE
	#undef IM



	/* As in the linalg package, the determinant is computed via LU factorization
	* using LAPACK.
	* slogdet computes sign + log(determinant).
	* det computes sign * exp(slogdet).
	*/
	#line 1084

	static inline void
	FLOAT_slogdet_single_element(fortran_int m,
	void* src,
	fortran_int* pivots,
	npy_float *sign,
	npy_float *logdet)
	{
	fortran_int info = 0;
	int i;
	/* note: done in place */
	LAPACK(sgetrf)(&m, &m, (void *)src, &m, pivots, &info);

	if (info == 0)
	{
	int change_sign = 0;
	/* note: fortran uses 1 based indexing */
	for (i=0; i < m; i++)
	{
	change_sign += (pivots[i] != (i+1));
	}

	memcpy(sign,
	(change_sign % 2)?
	&s_minus_one :
	&s_one
	, sizeof(*sign));
	FLOAT_slogdet_from_factored_diagonal(src, m, sign, logdet);
	} else {
	/*
	if getrf fails, use 0 as sign and -inf as logdet
	*/
	memcpy(sign, &s_zero, sizeof(*sign));
	memcpy(logdet, &s_ninf, sizeof(*logdet));
	}
	}

	static void
	FLOAT_slogdet(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	fortran_int m;
	npy_uint8 *tmp_buff = NULL;
	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_3
	m = (fortran_int) dimensions[0];
	matrix_size = mmsizeof(npy_float);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	/* 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_3
	linearize_FLOAT_matrix(tmp_buff, args[0], &lin_data);
	FLOAT_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	(npy_float*)args[1],
	(npy_float*)args[2]);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	static void
	FLOAT_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 = mmsizeof(npy_float);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	npy_float sign;
	npy_float 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_FLOAT_matrix(tmp_buff, args[0], &lin_data);
	FLOAT_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	&sign,
	&logdet);
	(npy_float )args[1] = FLOAT_det_from_slogdet(sign, logdet);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	#line 1084

	static inline void
	DOUBLE_slogdet_single_element(fortran_int m,
	void* src,
	fortran_int* pivots,
	npy_double *sign,
	npy_double *logdet)
	{
	fortran_int info = 0;
	int i;
	/* note: done in place */
	LAPACK(dgetrf)(&m, &m, (void *)src, &m, pivots, &info);

	if (info == 0)
	{
	int change_sign = 0;
	/* note: fortran uses 1 based indexing */
	for (i=0; i < m; i++)
	{
	change_sign += (pivots[i] != (i+1));
	}

	memcpy(sign,
	(change_sign % 2)?
	&d_minus_one :
	&d_one
	, sizeof(*sign));
	DOUBLE_slogdet_from_factored_diagonal(src, m, sign, logdet);
	} else {
	/*
	if getrf fails, use 0 as sign and -inf as logdet
	*/
	memcpy(sign, &d_zero, sizeof(*sign));
	memcpy(logdet, &d_ninf, sizeof(*logdet));
	}
	}

	static void
	DOUBLE_slogdet(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	fortran_int m;
	npy_uint8 *tmp_buff = NULL;
	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_3
	m = (fortran_int) dimensions[0];
	matrix_size = mmsizeof(npy_double);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	/* 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_3
	linearize_DOUBLE_matrix(tmp_buff, args[0], &lin_data);
	DOUBLE_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	(npy_double*)args[1],
	(npy_double*)args[2]);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	static void
	DOUBLE_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 = mmsizeof(npy_double);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	npy_double sign;
	npy_double 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_DOUBLE_matrix(tmp_buff, args[0], &lin_data);
	DOUBLE_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	&sign,
	&logdet);
	(npy_double )args[1] = DOUBLE_det_from_slogdet(sign, logdet);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	#line 1084

	static inline void
	CFLOAT_slogdet_single_element(fortran_int m,
	void* src,
	fortran_int* pivots,
	npy_cfloat *sign,
	npy_float *logdet)
	{
	fortran_int info = 0;
	int i;
	/* note: done in place */
	LAPACK(cgetrf)(&m, &m, (void *)src, &m, pivots, &info);

	if (info == 0)
	{
	int change_sign = 0;
	/* note: fortran uses 1 based indexing */
	for (i=0; i < m; i++)
	{
	change_sign += (pivots[i] != (i+1));
	}

	memcpy(sign,
	(change_sign % 2)?
	&c_minus_one :
	&c_one
	, sizeof(*sign));
	CFLOAT_slogdet_from_factored_diagonal(src, m, sign, logdet);
	} else {
	/*
	if getrf fails, use 0 as sign and -inf as logdet
	*/
	memcpy(sign, &c_zero, sizeof(*sign));
	memcpy(logdet, &c_ninf, sizeof(*logdet));
	}
	}

	static void
	CFLOAT_slogdet(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	fortran_int m;
	npy_uint8 *tmp_buff = NULL;
	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_3
	m = (fortran_int) dimensions[0];
	matrix_size = mmsizeof(npy_cfloat);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	/* 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_3
	linearize_CFLOAT_matrix(tmp_buff, args[0], &lin_data);
	CFLOAT_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	(npy_cfloat*)args[1],
	(npy_float*)args[2]);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	static void
	CFLOAT_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 = mmsizeof(npy_cfloat);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	npy_cfloat sign;
	npy_float 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_CFLOAT_matrix(tmp_buff, args[0], &lin_data);
	CFLOAT_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	&sign,
	&logdet);
	(npy_cfloat )args[1] = CFLOAT_det_from_slogdet(sign, logdet);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	#line 1084

	static inline void
	CDOUBLE_slogdet_single_element(fortran_int m,
	void* src,
	fortran_int* pivots,
	npy_cdouble *sign,
	npy_double *logdet)
	{
	fortran_int info = 0;
	int i;
	/* note: done in place */
	LAPACK(zgetrf)(&m, &m, (void *)src, &m, pivots, &info);

	if (info == 0)
	{
	int change_sign = 0;
	/* note: fortran uses 1 based indexing */
	for (i=0; i < m; i++)
	{
	change_sign += (pivots[i] != (i+1));
	}

	memcpy(sign,
	(change_sign % 2)?
	&z_minus_one :
	&z_one
	, sizeof(*sign));
	CDOUBLE_slogdet_from_factored_diagonal(src, m, sign, logdet);
	} else {
	/*
	if getrf fails, use 0 as sign and -inf as logdet
	*/
	memcpy(sign, &z_zero, sizeof(*sign));
	memcpy(logdet, &z_ninf, sizeof(*logdet));
	}
	}

	static void
	CDOUBLE_slogdet(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	fortran_int m;
	npy_uint8 *tmp_buff = NULL;
	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_3
	m = (fortran_int) dimensions[0];
	matrix_size = mmsizeof(npy_cdouble);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	/* 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_3
	linearize_CDOUBLE_matrix(tmp_buff, args[0], &lin_data);
	CDOUBLE_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	(npy_cdouble*)args[1],
	(npy_double*)args[2]);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}

	static void
	CDOUBLE_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 = mmsizeof(npy_cdouble);
	pivot_size = m*sizeof(fortran_int);
	tmp_buff = (npy_uint8 *)malloc(matrix_size + pivot_size);

	if (tmp_buff)
	{
	LINEARIZE_DATA_t lin_data;
	npy_cdouble sign;
	npy_double 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_CDOUBLE_matrix(tmp_buff, args[0], &lin_data);
	CDOUBLE_slogdet_single_element(m,
	(void*)tmp_buff,
	(fortran_int*)(tmp_buff+matrix_size),
	&sign,
	&logdet);
	(npy_cdouble )args[1] = CDOUBLE_det_from_slogdet(sign, logdet);
	END_OUTER_LOOP

	free(tmp_buff);
	}
	}



	/* -------------------------------------------------------------------------- */
	/* Eigh family */

	typedef struct eigh_params_struct {
	void A; / matrix */
	void W; / eigenvalue vector */
	void WORK; / main work buffer */
	void RWORK; / secondary work buffer (for complex versions) */
	void *IWORK;
	fortran_int N;
	fortran_int LWORK;
	fortran_int LRWORK;
	fortran_int LIWORK;
	char JOBZ;
	char UPLO;
	} EIGH_PARAMS_t;

	#line 1238

	/*
	* Initialize the parameters to use in for the lapack function _syevd
	* Handles buffer allocation
	*/
	static inline int
	init_ssyevd(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
	fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_float query_work_size;
	fortran_int query_iwork_size;
	fortran_int lwork = -1;
	fortran_int liwork = -1;
	fortran_int info;
	npy_uint8 a, w, work, iwork;
	size_t alloc_size = N(N+1)sizeof(npy_float);

	mem_buff = malloc(alloc_size);

	if (!mem_buff)
	goto error;
	a = mem_buff;
	w = mem_buff + NNsizeof(npy_float);
	LAPACK(ssyevd)(&JOBZ, &UPLO, &N,
	(fortran_real)a, &N, (fortran_real)w,
	&query_work_size, &lwork,
	&query_iwork_size, &liwork,
	&info);

	if (info != 0)
	goto error;

	work = mem_buff;
	lwork = (fortran_int)query_work_size;
	liwork = query_iwork_size;
	mem_buff2 = malloc(lworksizeof(npy_float) + liworksizeof(fortran_int));
	if (!mem_buff2)
	goto error;

	work = mem_buff2;
	iwork = mem_buff2 + lwork*sizeof(npy_float);

	params->A = a;
	params->W = w;
	params->WORK = work;
	params->RWORK = NULL; /* unused */
	params->IWORK = iwork;
	params->N = N;
	params->LWORK = lwork;
	params->LRWORK = 0; /* unused */
	params->LIWORK = liwork;
	params->JOBZ = JOBZ;
	params->UPLO = UPLO;

	return 1;

	error:
	/* something failed */
	memset(params, 0, sizeof(*params));
	free(mem_buff2);
	free(mem_buff);

	return 0;
	}

	static inline fortran_int
	call_ssyevd(EIGH_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(ssyevd)(&params->JOBZ, &params->UPLO, &params->N,
	params->A, &params->N, params->W,
	params->WORK, &params->LWORK,
	params->IWORK, &params->LIWORK,
	&rv);
	return rv;
	}

	#line 1238

	/*
	* Initialize the parameters to use in for the lapack function _syevd
	* Handles buffer allocation
	*/
	static inline int
	init_dsyevd(EIGH_PARAMS_t* params, char JOBZ, char UPLO,
	fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_double query_work_size;
	fortran_int query_iwork_size;
	fortran_int lwork = -1;
	fortran_int liwork = -1;
	fortran_int info;
	npy_uint8 a, w, work, iwork;
	size_t alloc_size = N(N+1)sizeof(npy_double);

	mem_buff = malloc(alloc_size);

	if (!mem_buff)
	goto error;
	a = mem_buff;
	w = mem_buff + NNsizeof(npy_double);
	LAPACK(dsyevd)(&JOBZ, &UPLO, &N,
	(fortran_doublereal)a, &N, (fortran_doublereal)w,
	&query_work_size, &lwork,
	&query_iwork_size, &liwork,
	&info);

	if (info != 0)
	goto error;

	work = mem_buff;
	lwork = (fortran_int)query_work_size;
	liwork = query_iwork_size;
	mem_buff2 = malloc(lworksizeof(npy_double) + liworksizeof(fortran_int));
	if (!mem_buff2)
	goto error;

	work = mem_buff2;
	iwork = mem_buff2 + lwork*sizeof(npy_double);

	params->A = a;
	params->W = w;
	params->WORK = work;
	params->RWORK = NULL; /* unused */
	params->IWORK = iwork;
	params->N = N;
	params->LWORK = lwork;
	params->LRWORK = 0; /* unused */
	params->LIWORK = liwork;
	params->JOBZ = JOBZ;
	params->UPLO = UPLO;

	return 1;

	error:
	/* something failed */
	memset(params, 0, sizeof(*params));
	free(mem_buff2);
	free(mem_buff);

	return 0;
	}

	static inline fortran_int
	call_dsyevd(EIGH_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(dsyevd)(&params->JOBZ, &params->UPLO, &params->N,
	params->A, &params->N, params->W,
	params->WORK, &params->LWORK,
	params->IWORK, &params->LIWORK,
	&rv);
	return rv;
	}



	#line 1327
	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_cheevd(EIGH_PARAMS_t *params,
	char JOBZ,
	char UPLO,
	fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	fortran_complex query_work_size;
	fortran_real query_rwork_size;
	fortran_int query_iwork_size;
	fortran_int lwork = -1;
	fortran_int lrwork = -1;
	fortran_int liwork = -1;
	npy_uint8 a, w, work, rwork, *iwork;
	fortran_int info;

	mem_buff = malloc(NNsizeof(npy_cfloat)+N*sizeof(npy_float));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	w = mem_buff+NNsizeof(npy_cfloat);

	LAPACK(cheevd)(&JOBZ, &UPLO, &N,
	(fortran_complex)a, &N, (fortran_real)w,
	&query_work_size, &lwork,
	&query_rwork_size, &lrwork,
	&query_iwork_size, &liwork,
	&info);
	if (info != 0)
	goto error;

	lwork = (fortran_int)(fortran_real)&query_work_size;
	lrwork = (fortran_int)query_rwork_size;
	liwork = query_iwork_size;

	mem_buff2 = malloc(lwork*sizeof(npy_cfloat) +
	lrwork*sizeof(npy_float) +
	liwork*sizeof(fortran_int));
	if (!mem_buff2)
	goto error;
	work = mem_buff2;
	rwork = work + lwork*sizeof(npy_cfloat);
	iwork = rwork + lrwork*sizeof(npy_float);

	params->A = a;
	params->W = w;
	params->WORK = work;
	params->RWORK = rwork;
	params->IWORK = iwork;
	params->N = N;
	params->LWORK = lwork;
	params->LRWORK = lrwork;
	params->LIWORK = liwork;
	params->JOBZ = JOBZ;
	params->UPLO = UPLO;

	return 1;

	/* something failed */
	error:
	memset(params, 0, sizeof(*params));
	free(mem_buff2);
	free(mem_buff);

	return 0;
	}

	static inline fortran_int
	call_cheevd(EIGH_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(cheevd)(&params->JOBZ, &params->UPLO, &params->N,
	params->A, &params->N, params->W,
	params->WORK, &params->LWORK,
	params->RWORK, &params->LRWORK,
	params->IWORK, &params->LIWORK,
	&rv);
	return rv;
	}

	#line 1327
	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_zheevd(EIGH_PARAMS_t *params,
	char JOBZ,
	char UPLO,
	fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	fortran_doublecomplex query_work_size;
	fortran_doublereal query_rwork_size;
	fortran_int query_iwork_size;
	fortran_int lwork = -1;
	fortran_int lrwork = -1;
	fortran_int liwork = -1;
	npy_uint8 a, w, work, rwork, *iwork;
	fortran_int info;

	mem_buff = malloc(NNsizeof(npy_cdouble)+N*sizeof(npy_double));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	w = mem_buff+NNsizeof(npy_cdouble);

	LAPACK(zheevd)(&JOBZ, &UPLO, &N,
	(fortran_doublecomplex)a, &N, (fortran_doublereal)w,
	&query_work_size, &lwork,
	&query_rwork_size, &lrwork,
	&query_iwork_size, &liwork,
	&info);
	if (info != 0)
	goto error;

	lwork = (fortran_int)(fortran_doublereal)&query_work_size;
	lrwork = (fortran_int)query_rwork_size;
	liwork = query_iwork_size;

	mem_buff2 = malloc(lwork*sizeof(npy_cdouble) +
	lrwork*sizeof(npy_double) +
	liwork*sizeof(fortran_int));
	if (!mem_buff2)
	goto error;
	work = mem_buff2;
	rwork = work + lwork*sizeof(npy_cdouble);
	iwork = rwork + lrwork*sizeof(npy_double);

	params->A = a;
	params->W = w;
	params->WORK = work;
	params->RWORK = rwork;
	params->IWORK = iwork;
	params->N = N;
	params->LWORK = lwork;
	params->LRWORK = lrwork;
	params->LIWORK = liwork;
	params->JOBZ = JOBZ;
	params->UPLO = UPLO;

	return 1;

	/* something failed */
	error:
	memset(params, 0, sizeof(*params));
	free(mem_buff2);
	free(mem_buff);

	return 0;
	}

	static inline fortran_int
	call_zheevd(EIGH_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(zheevd)(&params->JOBZ, &params->UPLO, &params->N,
	params->A, &params->N, params->W,
	params->WORK, &params->LWORK,
	params->RWORK, &params->LRWORK,
	params->IWORK, &params->LIWORK,
	&rv);
	return rv;
	}



	#line 1421
	/*
	* (M,M)->(M,)(M,M)
	* dimensions[1] -> M
	* args[0] -> A[in]
	* args[1] -> W
	* args[2] -> A[out]
	*/

	static inline void
	release_ssyevd(EIGH_PARAMS_t *params)
	{
	/* allocated memory in A and WORK */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}


	static inline void
	FLOAT_eigh_wrapper(char JOBZ,
	char UPLO,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[3];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:3;
	EIGH_PARAMS_t eigh_params;
	int error_occurred = get_fp_invalid_and_clear();

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_ssyevd(&eigh_params,
	JOBZ,
	UPLO,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t matrix_in_ld;
	LINEARIZE_DATA_t eigenvectors_out_ld;
	LINEARIZE_DATA_t eigenvalues_out_ld;

	init_linearize_data(&matrix_in_ld,
	eigh_params.N, eigh_params.N,
	steps[1], steps[0]);
	init_linearize_data(&eigenvalues_out_ld,
	1, eigh_params.N,
	0, steps[2]);
	if ('V' == eigh_params.JOBZ) {
	init_linearize_data(&eigenvectors_out_ld,
	eigh_params.N, eigh_params.N,
	steps[4], steps[3]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_FLOAT_matrix(eigh_params.A, args[0], &matrix_in_ld);
	not_ok = call_ssyevd(&eigh_params);
	if (!not_ok) {
	/* lapack ok, copy result out */
	delinearize_FLOAT_matrix(args[1],
	eigh_params.W,
	&eigenvalues_out_ld);

	if ('V' == eigh_params.JOBZ) {
	delinearize_FLOAT_matrix(args[2],
	eigh_params.A,
	&eigenvectors_out_ld);
	}
	} else {
	/* lapack fail, set result to nan */
	error_occurred = 1;
	nan_FLOAT_matrix(args[1], &eigenvalues_out_ld);
	if ('V' == eigh_params.JOBZ) {
	nan_FLOAT_matrix(args[2], &eigenvectors_out_ld);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_ssyevd(&eigh_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	#line 1421
	/*
	* (M,M)->(M,)(M,M)
	* dimensions[1] -> M
	* args[0] -> A[in]
	* args[1] -> W
	* args[2] -> A[out]
	*/

	static inline void
	release_dsyevd(EIGH_PARAMS_t *params)
	{
	/* allocated memory in A and WORK */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}


	static inline void
	DOUBLE_eigh_wrapper(char JOBZ,
	char UPLO,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[3];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:3;
	EIGH_PARAMS_t eigh_params;
	int error_occurred = get_fp_invalid_and_clear();

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_dsyevd(&eigh_params,
	JOBZ,
	UPLO,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t matrix_in_ld;
	LINEARIZE_DATA_t eigenvectors_out_ld;
	LINEARIZE_DATA_t eigenvalues_out_ld;

	init_linearize_data(&matrix_in_ld,
	eigh_params.N, eigh_params.N,
	steps[1], steps[0]);
	init_linearize_data(&eigenvalues_out_ld,
	1, eigh_params.N,
	0, steps[2]);
	if ('V' == eigh_params.JOBZ) {
	init_linearize_data(&eigenvectors_out_ld,
	eigh_params.N, eigh_params.N,
	steps[4], steps[3]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_DOUBLE_matrix(eigh_params.A, args[0], &matrix_in_ld);
	not_ok = call_dsyevd(&eigh_params);
	if (!not_ok) {
	/* lapack ok, copy result out */
	delinearize_DOUBLE_matrix(args[1],
	eigh_params.W,
	&eigenvalues_out_ld);

	if ('V' == eigh_params.JOBZ) {
	delinearize_DOUBLE_matrix(args[2],
	eigh_params.A,
	&eigenvectors_out_ld);
	}
	} else {
	/* lapack fail, set result to nan */
	error_occurred = 1;
	nan_DOUBLE_matrix(args[1], &eigenvalues_out_ld);
	if ('V' == eigh_params.JOBZ) {
	nan_DOUBLE_matrix(args[2], &eigenvectors_out_ld);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_dsyevd(&eigh_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	#line 1421
	/*
	* (M,M)->(M,)(M,M)
	* dimensions[1] -> M
	* args[0] -> A[in]
	* args[1] -> W
	* args[2] -> A[out]
	*/

	static inline void
	release_cheevd(EIGH_PARAMS_t *params)
	{
	/* allocated memory in A and WORK */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}


	static inline void
	CFLOAT_eigh_wrapper(char JOBZ,
	char UPLO,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[3];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:3;
	EIGH_PARAMS_t eigh_params;
	int error_occurred = get_fp_invalid_and_clear();

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_cheevd(&eigh_params,
	JOBZ,
	UPLO,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t matrix_in_ld;
	LINEARIZE_DATA_t eigenvectors_out_ld;
	LINEARIZE_DATA_t eigenvalues_out_ld;

	init_linearize_data(&matrix_in_ld,
	eigh_params.N, eigh_params.N,
	steps[1], steps[0]);
	init_linearize_data(&eigenvalues_out_ld,
	1, eigh_params.N,
	0, steps[2]);
	if ('V' == eigh_params.JOBZ) {
	init_linearize_data(&eigenvectors_out_ld,
	eigh_params.N, eigh_params.N,
	steps[4], steps[3]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_CFLOAT_matrix(eigh_params.A, args[0], &matrix_in_ld);
	not_ok = call_cheevd(&eigh_params);
	if (!not_ok) {
	/* lapack ok, copy result out */
	delinearize_FLOAT_matrix(args[1],
	eigh_params.W,
	&eigenvalues_out_ld);

	if ('V' == eigh_params.JOBZ) {
	delinearize_CFLOAT_matrix(args[2],
	eigh_params.A,
	&eigenvectors_out_ld);
	}
	} else {
	/* lapack fail, set result to nan */
	error_occurred = 1;
	nan_FLOAT_matrix(args[1], &eigenvalues_out_ld);
	if ('V' == eigh_params.JOBZ) {
	nan_CFLOAT_matrix(args[2], &eigenvectors_out_ld);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_cheevd(&eigh_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	#line 1421
	/*
	* (M,M)->(M,)(M,M)
	* dimensions[1] -> M
	* args[0] -> A[in]
	* args[1] -> W
	* args[2] -> A[out]
	*/

	static inline void
	release_zheevd(EIGH_PARAMS_t *params)
	{
	/* allocated memory in A and WORK */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}


	static inline void
	CDOUBLE_eigh_wrapper(char JOBZ,
	char UPLO,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[3];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:3;
	EIGH_PARAMS_t eigh_params;
	int error_occurred = get_fp_invalid_and_clear();

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_zheevd(&eigh_params,
	JOBZ,
	UPLO,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t matrix_in_ld;
	LINEARIZE_DATA_t eigenvectors_out_ld;
	LINEARIZE_DATA_t eigenvalues_out_ld;

	init_linearize_data(&matrix_in_ld,
	eigh_params.N, eigh_params.N,
	steps[1], steps[0]);
	init_linearize_data(&eigenvalues_out_ld,
	1, eigh_params.N,
	0, steps[2]);
	if ('V' == eigh_params.JOBZ) {
	init_linearize_data(&eigenvectors_out_ld,
	eigh_params.N, eigh_params.N,
	steps[4], steps[3]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_CDOUBLE_matrix(eigh_params.A, args[0], &matrix_in_ld);
	not_ok = call_zheevd(&eigh_params);
	if (!not_ok) {
	/* lapack ok, copy result out */
	delinearize_DOUBLE_matrix(args[1],
	eigh_params.W,
	&eigenvalues_out_ld);

	if ('V' == eigh_params.JOBZ) {
	delinearize_CDOUBLE_matrix(args[2],
	eigh_params.A,
	&eigenvectors_out_ld);
	}
	} else {
	/* lapack fail, set result to nan */
	error_occurred = 1;
	nan_DOUBLE_matrix(args[1], &eigenvalues_out_ld);
	if ('V' == eigh_params.JOBZ) {
	nan_CDOUBLE_matrix(args[2], &eigenvectors_out_ld);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_zheevd(&eigh_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}



	#line 1516
	static void
	FLOAT_eighlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_eigh_wrapper('V', 'L', args, dimensions, steps);
	}

	static void
	FLOAT_eighup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	FLOAT_eigh_wrapper('V', 'U', args, dimensions, steps);
	}

	static void
	FLOAT_eigvalshlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	FLOAT_eigh_wrapper('N', 'L', args, dimensions, steps);
	}

	static void
	FLOAT_eigvalshup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	FLOAT_eigh_wrapper('N', 'U', args, dimensions, steps);
	}

	#line 1516
	static void
	DOUBLE_eighlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_eigh_wrapper('V', 'L', args, dimensions, steps);
	}

	static void
	DOUBLE_eighup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	DOUBLE_eigh_wrapper('V', 'U', args, dimensions, steps);
	}

	static void
	DOUBLE_eigvalshlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	DOUBLE_eigh_wrapper('N', 'L', args, dimensions, steps);
	}

	static void
	DOUBLE_eigvalshup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	DOUBLE_eigh_wrapper('N', 'U', args, dimensions, steps);
	}

	#line 1516
	static void
	CFLOAT_eighlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CFLOAT_eigh_wrapper('V', 'L', args, dimensions, steps);
	}

	static void
	CFLOAT_eighup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CFLOAT_eigh_wrapper('V', 'U', args, dimensions, steps);
	}

	static void
	CFLOAT_eigvalshlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CFLOAT_eigh_wrapper('N', 'L', args, dimensions, steps);
	}

	static void
	CFLOAT_eigvalshup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CFLOAT_eigh_wrapper('N', 'U', args, dimensions, steps);
	}

	#line 1516
	static void
	CDOUBLE_eighlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_eigh_wrapper('V', 'L', args, dimensions, steps);
	}

	static void
	CDOUBLE_eighup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CDOUBLE_eigh_wrapper('V', 'U', args, dimensions, steps);
	}

	static void
	CDOUBLE_eigvalshlo(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CDOUBLE_eigh_wrapper('N', 'L', args, dimensions, steps);
	}

	static void
	CDOUBLE_eigvalshup(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void* NPY_UNUSED(func))
	{
	CDOUBLE_eigh_wrapper('N', 'U', args, dimensions, steps);
	}


	/* -------------------------------------------------------------------------- */
	/* Solve family (includes inv) */

	typedef struct gesv_params_struct
	{
	void A; / A is (N,N) of base type */
	void B; / B is (N,NRHS) of base type */
	fortran_int * IPIV; /* IPIV is (N) */

	fortran_int N;
	fortran_int NRHS;
	fortran_int LDA;
	fortran_int LDB;
	} GESV_PARAMS_t;

	#line 1574

	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_sgesv(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 a, b, *ipiv;
	mem_buff = malloc(NNsizeof(fortran_real) +
	NNRHSsizeof(fortran_real) +
	N*sizeof(fortran_int));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	b = a + NNsizeof(fortran_real);
	ipiv = b + NNRHSsizeof(fortran_real);

	params->A = a;
	params->B = b;
	params->IPIV = (fortran_int*)ipiv;
	params->N = N;
	params->NRHS = NRHS;
	params->LDA = N;
	params->LDB = N;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_sgesv(GESV_PARAMS_t *params)
	{
	/* memory block base is in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_sgesv(GESV_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(sgesv)(&params->N, &params->NRHS,
	params->A, &params->LDA,
	params->IPIV,
	params->B, &params->LDB,
	&rv);
	return rv;
	}

	static void
	FLOAT_solve(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n, nrhs;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	nrhs = (fortran_int)dimensions[1];
	if (init_sgesv(&params, n, nrhs)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;

	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, nrhs, n, steps[3], steps[2]);
	init_linearize_data(&r_out, nrhs, n, steps[5], steps[4]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_FLOAT_matrix(params.A, args[0], &a_in);
	linearize_FLOAT_matrix(params.B, args[1], &b_in);
	not_ok =call_sgesv(&params);
	if (!not_ok) {
	delinearize_FLOAT_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_FLOAT_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_sgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	FLOAT_solve1(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	if (init_sgesv(&params, n, 1)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, 1, n, 1, steps[2]);
	init_linearize_data(&r_out, 1, n, 1, steps[3]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_FLOAT_matrix(params.A, args[0], &a_in);
	linearize_FLOAT_matrix(params.B, args[1], &b_in);
	not_ok = call_sgesv(&params);
	if (!not_ok) {
	delinearize_FLOAT_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_FLOAT_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_sgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	FLOAT_inv(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_2

	n = (fortran_int)dimensions[0];
	if (init_sgesv(&params, n, n)) {
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);

	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_FLOAT_matrix(params.A, args[0], &a_in);
	identity_FLOAT_matrix(params.B, n);
	not_ok = call_sgesv(&params);
	if (!not_ok) {
	delinearize_FLOAT_matrix(args[1], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_FLOAT_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP

	release_sgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}


	#line 1574

	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_dgesv(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 a, b, *ipiv;
	mem_buff = malloc(NNsizeof(fortran_doublereal) +
	NNRHSsizeof(fortran_doublereal) +
	N*sizeof(fortran_int));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	b = a + NNsizeof(fortran_doublereal);
	ipiv = b + NNRHSsizeof(fortran_doublereal);

	params->A = a;
	params->B = b;
	params->IPIV = (fortran_int*)ipiv;
	params->N = N;
	params->NRHS = NRHS;
	params->LDA = N;
	params->LDB = N;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_dgesv(GESV_PARAMS_t *params)
	{
	/* memory block base is in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_dgesv(GESV_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(dgesv)(&params->N, &params->NRHS,
	params->A, &params->LDA,
	params->IPIV,
	params->B, &params->LDB,
	&rv);
	return rv;
	}

	static void
	DOUBLE_solve(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n, nrhs;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	nrhs = (fortran_int)dimensions[1];
	if (init_dgesv(&params, n, nrhs)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;

	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, nrhs, n, steps[3], steps[2]);
	init_linearize_data(&r_out, nrhs, n, steps[5], steps[4]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_DOUBLE_matrix(params.A, args[0], &a_in);
	linearize_DOUBLE_matrix(params.B, args[1], &b_in);
	not_ok =call_dgesv(&params);
	if (!not_ok) {
	delinearize_DOUBLE_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_DOUBLE_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_dgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	DOUBLE_solve1(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	if (init_dgesv(&params, n, 1)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, 1, n, 1, steps[2]);
	init_linearize_data(&r_out, 1, n, 1, steps[3]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_DOUBLE_matrix(params.A, args[0], &a_in);
	linearize_DOUBLE_matrix(params.B, args[1], &b_in);
	not_ok = call_dgesv(&params);
	if (!not_ok) {
	delinearize_DOUBLE_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_DOUBLE_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_dgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	DOUBLE_inv(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_2

	n = (fortran_int)dimensions[0];
	if (init_dgesv(&params, n, n)) {
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);

	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_DOUBLE_matrix(params.A, args[0], &a_in);
	identity_DOUBLE_matrix(params.B, n);
	not_ok = call_dgesv(&params);
	if (!not_ok) {
	delinearize_DOUBLE_matrix(args[1], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_DOUBLE_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP

	release_dgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}


	#line 1574

	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_cgesv(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 a, b, *ipiv;
	mem_buff = malloc(NNsizeof(fortran_complex) +
	NNRHSsizeof(fortran_complex) +
	N*sizeof(fortran_int));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	b = a + NNsizeof(fortran_complex);
	ipiv = b + NNRHSsizeof(fortran_complex);

	params->A = a;
	params->B = b;
	params->IPIV = (fortran_int*)ipiv;
	params->N = N;
	params->NRHS = NRHS;
	params->LDA = N;
	params->LDB = N;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_cgesv(GESV_PARAMS_t *params)
	{
	/* memory block base is in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_cgesv(GESV_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(cgesv)(&params->N, &params->NRHS,
	params->A, &params->LDA,
	params->IPIV,
	params->B, &params->LDB,
	&rv);
	return rv;
	}

	static void
	CFLOAT_solve(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n, nrhs;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	nrhs = (fortran_int)dimensions[1];
	if (init_cgesv(&params, n, nrhs)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;

	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, nrhs, n, steps[3], steps[2]);
	init_linearize_data(&r_out, nrhs, n, steps[5], steps[4]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_CFLOAT_matrix(params.A, args[0], &a_in);
	linearize_CFLOAT_matrix(params.B, args[1], &b_in);
	not_ok =call_cgesv(&params);
	if (!not_ok) {
	delinearize_CFLOAT_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CFLOAT_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_cgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CFLOAT_solve1(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	if (init_cgesv(&params, n, 1)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, 1, n, 1, steps[2]);
	init_linearize_data(&r_out, 1, n, 1, steps[3]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_CFLOAT_matrix(params.A, args[0], &a_in);
	linearize_CFLOAT_matrix(params.B, args[1], &b_in);
	not_ok = call_cgesv(&params);
	if (!not_ok) {
	delinearize_CFLOAT_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CFLOAT_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_cgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CFLOAT_inv(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_2

	n = (fortran_int)dimensions[0];
	if (init_cgesv(&params, n, n)) {
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);

	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_CFLOAT_matrix(params.A, args[0], &a_in);
	identity_CFLOAT_matrix(params.B, n);
	not_ok = call_cgesv(&params);
	if (!not_ok) {
	delinearize_CFLOAT_matrix(args[1], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CFLOAT_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP

	release_cgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}


	#line 1574

	/*
	* Initialize the parameters to use in for the lapack function _heev
	* Handles buffer allocation
	*/
	static inline int
	init_zgesv(GESV_PARAMS_t *params, fortran_int N, fortran_int NRHS)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 a, b, *ipiv;
	mem_buff = malloc(NNsizeof(fortran_doublecomplex) +
	NNRHSsizeof(fortran_doublecomplex) +
	N*sizeof(fortran_int));
	if (!mem_buff)
	goto error;
	a = mem_buff;
	b = a + NNsizeof(fortran_doublecomplex);
	ipiv = b + NNRHSsizeof(fortran_doublecomplex);

	params->A = a;
	params->B = b;
	params->IPIV = (fortran_int*)ipiv;
	params->N = N;
	params->NRHS = NRHS;
	params->LDA = N;
	params->LDB = N;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_zgesv(GESV_PARAMS_t *params)
	{
	/* memory block base is in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_zgesv(GESV_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(zgesv)(&params->N, &params->NRHS,
	params->A, &params->LDA,
	params->IPIV,
	params->B, &params->LDB,
	&rv);
	return rv;
	}

	static void
	CDOUBLE_solve(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n, nrhs;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	nrhs = (fortran_int)dimensions[1];
	if (init_zgesv(&params, n, nrhs)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;

	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, nrhs, n, steps[3], steps[2]);
	init_linearize_data(&r_out, nrhs, n, steps[5], steps[4]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_CDOUBLE_matrix(params.A, args[0], &a_in);
	linearize_CDOUBLE_matrix(params.B, args[1], &b_in);
	not_ok =call_zgesv(&params);
	if (!not_ok) {
	delinearize_CDOUBLE_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CDOUBLE_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_zgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CDOUBLE_solve1(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_3

	n = (fortran_int)dimensions[0];
	if (init_zgesv(&params, n, 1)) {
	LINEARIZE_DATA_t a_in, b_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&b_in, 1, n, 1, steps[2]);
	init_linearize_data(&r_out, 1, n, 1, steps[3]);

	BEGIN_OUTER_LOOP_3
	int not_ok;
	linearize_CDOUBLE_matrix(params.A, args[0], &a_in);
	linearize_CDOUBLE_matrix(params.B, args[1], &b_in);
	not_ok = call_zgesv(&params);
	if (!not_ok) {
	delinearize_CDOUBLE_matrix(args[2], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CDOUBLE_matrix(args[2], &r_out);
	}
	END_OUTER_LOOP

	release_zgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CDOUBLE_inv(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	GESV_PARAMS_t params;
	fortran_int n;
	int error_occurred = get_fp_invalid_and_clear();
	INIT_OUTER_LOOP_2

	n = (fortran_int)dimensions[0];
	if (init_zgesv(&params, n, n)) {
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);

	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_CDOUBLE_matrix(params.A, args[0], &a_in);
	identity_CDOUBLE_matrix(params.B, n);
	not_ok = call_zgesv(&params);
	if (!not_ok) {
	delinearize_CDOUBLE_matrix(args[1], params.B, &r_out);
	} else {
	error_occurred = 1;
	nan_CDOUBLE_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP

	release_zgesv(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}




	/* -------------------------------------------------------------------------- */
	/* Cholesky decomposition */

	typedef struct potr_params_struct
	{
	void *A;
	fortran_int N;
	fortran_int LDA;
	char UPLO;
	} POTR_PARAMS_t;

	#line 1756

	static inline int
	init_spotrf(POTR_PARAMS_t *params, char UPLO, fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *a;

	mem_buff = malloc(NNsizeof(fortran_real));
	if (!mem_buff)
	goto error;

	a = mem_buff;

	params->A = a;
	params->N = N;
	params->LDA = N;
	params->UPLO = UPLO;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_spotrf(POTR_PARAMS_t *params)
	{
	/* memory block base in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_spotrf(POTR_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(spotrf)(&params->UPLO,
	&params->N, params->A, &params->LDA,
	&rv);
	return rv;
	}

	static void
	FLOAT_cholesky(char uplo, char *args, npy_intp dimensions, npy_intp *steps)
	{
	POTR_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_2

	assert(uplo == 'L');

	n = (fortran_int)dimensions[0];
	if (init_spotrf(&params, uplo, n))
	{
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);
	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_FLOAT_matrix(params.A, args[0], &a_in);
	not_ok = call_spotrf(&params);
	if (!not_ok) {
	triu_FLOAT_matrix(params.A, params.N);
	delinearize_FLOAT_matrix(args[1], params.A, &r_out);
	} else {
	error_occurred = 1;
	nan_FLOAT_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP
	release_spotrf(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	FLOAT_cholesky_lo(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_cholesky('L', args, dimensions, steps);
	}


	#line 1756

	static inline int
	init_dpotrf(POTR_PARAMS_t *params, char UPLO, fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *a;

	mem_buff = malloc(NNsizeof(fortran_doublereal));
	if (!mem_buff)
	goto error;

	a = mem_buff;

	params->A = a;
	params->N = N;
	params->LDA = N;
	params->UPLO = UPLO;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_dpotrf(POTR_PARAMS_t *params)
	{
	/* memory block base in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_dpotrf(POTR_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(dpotrf)(&params->UPLO,
	&params->N, params->A, &params->LDA,
	&rv);
	return rv;
	}

	static void
	DOUBLE_cholesky(char uplo, char *args, npy_intp dimensions, npy_intp *steps)
	{
	POTR_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_2

	assert(uplo == 'L');

	n = (fortran_int)dimensions[0];
	if (init_dpotrf(&params, uplo, n))
	{
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);
	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_DOUBLE_matrix(params.A, args[0], &a_in);
	not_ok = call_dpotrf(&params);
	if (!not_ok) {
	triu_DOUBLE_matrix(params.A, params.N);
	delinearize_DOUBLE_matrix(args[1], params.A, &r_out);
	} else {
	error_occurred = 1;
	nan_DOUBLE_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP
	release_dpotrf(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	DOUBLE_cholesky_lo(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_cholesky('L', args, dimensions, steps);
	}


	#line 1756

	static inline int
	init_cpotrf(POTR_PARAMS_t *params, char UPLO, fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *a;

	mem_buff = malloc(NNsizeof(fortran_complex));
	if (!mem_buff)
	goto error;

	a = mem_buff;

	params->A = a;
	params->N = N;
	params->LDA = N;
	params->UPLO = UPLO;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_cpotrf(POTR_PARAMS_t *params)
	{
	/* memory block base in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_cpotrf(POTR_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(cpotrf)(&params->UPLO,
	&params->N, params->A, &params->LDA,
	&rv);
	return rv;
	}

	static void
	CFLOAT_cholesky(char uplo, char *args, npy_intp dimensions, npy_intp *steps)
	{
	POTR_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_2

	assert(uplo == 'L');

	n = (fortran_int)dimensions[0];
	if (init_cpotrf(&params, uplo, n))
	{
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);
	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_CFLOAT_matrix(params.A, args[0], &a_in);
	not_ok = call_cpotrf(&params);
	if (!not_ok) {
	triu_CFLOAT_matrix(params.A, params.N);
	delinearize_CFLOAT_matrix(args[1], params.A, &r_out);
	} else {
	error_occurred = 1;
	nan_CFLOAT_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP
	release_cpotrf(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CFLOAT_cholesky_lo(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CFLOAT_cholesky('L', args, dimensions, steps);
	}


	#line 1756

	static inline int
	init_zpotrf(POTR_PARAMS_t *params, char UPLO, fortran_int N)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *a;

	mem_buff = malloc(NNsizeof(fortran_doublecomplex));
	if (!mem_buff)
	goto error;

	a = mem_buff;

	params->A = a;
	params->N = N;
	params->LDA = N;
	params->UPLO = UPLO;

	return 1;
	error:
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline void
	release_zpotrf(POTR_PARAMS_t *params)
	{
	/* memory block base in A */
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline fortran_int
	call_zpotrf(POTR_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(zpotrf)(&params->UPLO,
	&params->N, params->A, &params->LDA,
	&rv);
	return rv;
	}

	static void
	CDOUBLE_cholesky(char uplo, char *args, npy_intp dimensions, npy_intp *steps)
	{
	POTR_PARAMS_t params;
	int error_occurred = get_fp_invalid_and_clear();
	fortran_int n;
	INIT_OUTER_LOOP_2

	assert(uplo == 'L');

	n = (fortran_int)dimensions[0];
	if (init_zpotrf(&params, uplo, n))
	{
	LINEARIZE_DATA_t a_in, r_out;
	init_linearize_data(&a_in, n, n, steps[1], steps[0]);
	init_linearize_data(&r_out, n, n, steps[3], steps[2]);
	BEGIN_OUTER_LOOP_2
	int not_ok;
	linearize_CDOUBLE_matrix(params.A, args[0], &a_in);
	not_ok = call_zpotrf(&params);
	if (!not_ok) {
	triu_CDOUBLE_matrix(params.A, params.N);
	delinearize_CDOUBLE_matrix(args[1], params.A, &r_out);
	} else {
	error_occurred = 1;
	nan_CDOUBLE_matrix(args[1], &r_out);
	}
	END_OUTER_LOOP
	release_zpotrf(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CDOUBLE_cholesky_lo(char *args, npy_intp dimensions, npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_cholesky('L', args, dimensions, steps);
	}



	/* -------------------------------------------------------------------------- */
	/* eig family */

	typedef struct geev_params_struct {
	void *A;
	void WR; / RWORK in complex versions, REAL W buffer for (sd)geev*/
	void *WI;
	void VLR; / REAL VL buffers for _geev where _ is s, d */
	void VRR; / REAL VR buffers for _geev hwere _ is s, d */
	void *WORK;
	void W; / final w */
	void VL; / final vl */
	void VR; / final vr */

	fortran_int N;
	fortran_int LDA;
	fortran_int LDVL;
	fortran_int LDVR;
	fortran_int LWORK;

	char JOBVL;
	char JOBVR;
	} GEEV_PARAMS_t;

	static inline void
	dump_geev_params(const char name, GEEV_PARAMS_t params)
	{
	TRACE_TXT("\n%s\n"

	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\
	"\t%10s: %p\n"\

	"\t%10s: %d\n"\
	"\t%10s: %d\n"\
	"\t%10s: %d\n"\
	"\t%10s: %d\n"\
	"\t%10s: %d\n"\

	"\t%10s: %c\n"\
	"\t%10s: %c\n",

	name,

	"A", params->A,
	"WR", params->WR,
	"WI", params->WI,
	"VLR", params->VLR,
	"VRR", params->VRR,
	"WORK", params->WORK,
	"W", params->W,
	"VL", params->VL,
	"VR", params->VR,

	"N", (int)params->N,
	"LDA", (int)params->LDA,
	"LDVL", (int)params->LDVL,
	"LDVR", (int)params->LDVR,
	"LWORK", (int)params->LWORK,

	"JOBVL", params->JOBVL,
	"JOBVR", params->JOBVR);
	}

	#line 1921
	static inline int
	init_sgeev(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
	{
	npy_uint8 *mem_buff=NULL;
	npy_uint8 *mem_buff2=NULL;
	npy_uint8 a, wr, wi, vlr, vrr, work, w, vl, *vr;
	size_t a_size = nnsizeof(float);
	size_t wr_size = n*sizeof(float);
	size_t wi_size = n*sizeof(float);
	size_t vlr_size = jobvl=='V' ? nnsizeof(float) : 0;
	size_t vrr_size = jobvr=='V' ? nnsizeof(float) : 0;
	size_t w_size = wr_size*2;
	size_t vl_size = vlr_size*2;
	size_t vr_size = vrr_size*2;
	size_t work_count = 0;
	float work_size_query;
	fortran_int do_size_query = -1;
	fortran_int rv;

	/* allocate data for known sizes (all but work) */
	mem_buff = malloc(a_size + wr_size + wi_size +
	vlr_size + vrr_size +
	w_size + vl_size + vr_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	wr = a + a_size;
	wi = wr + wr_size;
	vlr = wi + wi_size;
	vrr = vlr + vlr_size;
	w = vrr + vrr_size;
	vl = w + w_size;
	vr = vl + vl_size;
	LAPACK(sgeev)(&jobvl, &jobvr, &n,
	(void )a, &n, (void )wr, (void *)wi,
	(void )vl, &n, (void )vr, &n,
	&work_size_query, &do_size_query,
	&rv);

	if (0 != rv)
	goto error;

	work_count = (size_t)work_size_query;
	mem_buff2 = malloc(work_count*sizeof(float));
	if (!mem_buff2)
	goto error;
	work = mem_buff2;

	params->A = a;
	params->WR = wr;
	params->WI = wi;
	params->VLR = vlr;
	params->VRR = vrr;
	params->WORK = work;
	params->W = w;
	params->VL = vl;
	params->VR = vr;
	params->N = n;
	params->LDA = n;
	params->LDVL = n;
	params->LDVR = n;
	params->LWORK = (fortran_int)work_count;
	params->JOBVL = jobvl;
	params->JOBVR = jobvr;

	return 1;
	error:
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_sgeev(GEEV_PARAMS_t* params)
	{
	fortran_int rv;
	LAPACK(sgeev)(&params->JOBVL, &params->JOBVR,
	&params->N, params->A, &params->LDA,
	params->WR, params->WI,
	params->VLR, &params->LDVL,
	params->VRR, &params->LDVR,
	params->WORK, &params->LWORK,
	&rv);
	return rv;
	}


	static inline void
	mk_FLOAT_complex_array_from_real(COMPLEX_t c, const float re, size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	c[iter].array[0] = re[iter];
	c[iter].array[1] = 0.0f;
	}
	}

	static inline void
	mk_FLOAT_complex_array(COMPLEX_t *c,
	const float *re,
	const float *im,
	size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	c[iter].array[0] = re[iter];
	c[iter].array[1] = im[iter];
	}
	}

	static inline void
	mk_FLOAT_complex_array_conjugate_pair(COMPLEX_t *c,
	const float *r,
	size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	float re = r[iter];
	float im = r[iter+n];
	c[iter].array[0] = re;
	c[iter].array[1] = im;
	c[iter+n].array[0] = re;
	c[iter+n].array[1] = -im;
	}
	}

	/*
	* make the complex eigenvectors from the real array produced by sgeev/zgeev.
	* c is the array where the results will be left.
	* r is the source array of reals produced by sgeev/zgeev
	* i is the eigenvalue imaginary part produced by sgeev/zgeev
	* n is so that the order of the matrix is n by n
	*/
	static inline void
	mk_sgeev_complex_eigenvectors(COMPLEX_t *c,
	const float *r,
	const float *i,
	size_t n)
	{
	size_t iter = 0;
	while (iter < n)
	{
	if (i[iter] == 0.0f) {
	/* eigenvalue was real, eigenvectors as well... */
	mk_FLOAT_complex_array_from_real(c, r, n);
	c += n;
	r += n;
	iter ++;
	} else {
	/* eigenvalue was complex, generate a pair of eigenvectors */
	mk_FLOAT_complex_array_conjugate_pair(c, r, n);
	c += 2*n;
	r += 2*n;
	iter += 2;
	}
	}
	}


	static inline void
	process_sgeev_results(GEEV_PARAMS_t *params)
	{
	/* REAL versions of geev need the results to be translated
	* into complex versions. This is the way to deal with imaginary
	* results. In our gufuncs we will always return complex arrays!
	*/
	mk_FLOAT_complex_array(params->W, params->WR, params->WI, params->N);

	/* handle the eigenvectors */
	if ('V' == params->JOBVL) {
	mk_sgeev_complex_eigenvectors(params->VL, params->VLR,
	params->WI, params->N);
	}
	if ('V' == params->JOBVR) {
	mk_sgeev_complex_eigenvectors(params->VR, params->VRR,
	params->WI, params->N);
	}
	}


	#line 1921
	static inline int
	init_dgeev(GEEV_PARAMS_t *params, char jobvl, char jobvr, fortran_int n)
	{
	npy_uint8 *mem_buff=NULL;
	npy_uint8 *mem_buff2=NULL;
	npy_uint8 a, wr, wi, vlr, vrr, work, w, vl, *vr;
	size_t a_size = nnsizeof(double);
	size_t wr_size = n*sizeof(double);
	size_t wi_size = n*sizeof(double);
	size_t vlr_size = jobvl=='V' ? nnsizeof(double) : 0;
	size_t vrr_size = jobvr=='V' ? nnsizeof(double) : 0;
	size_t w_size = wr_size*2;
	size_t vl_size = vlr_size*2;
	size_t vr_size = vrr_size*2;
	size_t work_count = 0;
	double work_size_query;
	fortran_int do_size_query = -1;
	fortran_int rv;

	/* allocate data for known sizes (all but work) */
	mem_buff = malloc(a_size + wr_size + wi_size +
	vlr_size + vrr_size +
	w_size + vl_size + vr_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	wr = a + a_size;
	wi = wr + wr_size;
	vlr = wi + wi_size;
	vrr = vlr + vlr_size;
	w = vrr + vrr_size;
	vl = w + w_size;
	vr = vl + vl_size;
	LAPACK(dgeev)(&jobvl, &jobvr, &n,
	(void )a, &n, (void )wr, (void *)wi,
	(void )vl, &n, (void )vr, &n,
	&work_size_query, &do_size_query,
	&rv);

	if (0 != rv)
	goto error;

	work_count = (size_t)work_size_query;
	mem_buff2 = malloc(work_count*sizeof(double));
	if (!mem_buff2)
	goto error;
	work = mem_buff2;

	params->A = a;
	params->WR = wr;
	params->WI = wi;
	params->VLR = vlr;
	params->VRR = vrr;
	params->WORK = work;
	params->W = w;
	params->VL = vl;
	params->VR = vr;
	params->N = n;
	params->LDA = n;
	params->LDVL = n;
	params->LDVR = n;
	params->LWORK = (fortran_int)work_count;
	params->JOBVL = jobvl;
	params->JOBVR = jobvr;

	return 1;
	error:
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_dgeev(GEEV_PARAMS_t* params)
	{
	fortran_int rv;
	LAPACK(dgeev)(&params->JOBVL, &params->JOBVR,
	&params->N, params->A, &params->LDA,
	params->WR, params->WI,
	params->VLR, &params->LDVL,
	params->VRR, &params->LDVR,
	params->WORK, &params->LWORK,
	&rv);
	return rv;
	}


	static inline void
	mk_DOUBLE_complex_array_from_real(DOUBLECOMPLEX_t c, const double re, size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	c[iter].array[0] = re[iter];
	c[iter].array[1] = 0.0;
	}
	}

	static inline void
	mk_DOUBLE_complex_array(DOUBLECOMPLEX_t *c,
	const double *re,
	const double *im,
	size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	c[iter].array[0] = re[iter];
	c[iter].array[1] = im[iter];
	}
	}

	static inline void
	mk_DOUBLE_complex_array_conjugate_pair(DOUBLECOMPLEX_t *c,
	const double *r,
	size_t n)
	{
	size_t iter;
	for (iter = 0; iter < n; ++iter) {
	double re = r[iter];
	double im = r[iter+n];
	c[iter].array[0] = re;
	c[iter].array[1] = im;
	c[iter+n].array[0] = re;
	c[iter+n].array[1] = -im;
	}
	}

	/*
	* make the complex eigenvectors from the real array produced by sgeev/zgeev.
	* c is the array where the results will be left.
	* r is the source array of reals produced by sgeev/zgeev
	* i is the eigenvalue imaginary part produced by sgeev/zgeev
	* n is so that the order of the matrix is n by n
	*/
	static inline void
	mk_dgeev_complex_eigenvectors(DOUBLECOMPLEX_t *c,
	const double *r,
	const double *i,
	size_t n)
	{
	size_t iter = 0;
	while (iter < n)
	{
	if (i[iter] == 0.0) {
	/* eigenvalue was real, eigenvectors as well... */
	mk_DOUBLE_complex_array_from_real(c, r, n);
	c += n;
	r += n;
	iter ++;
	} else {
	/* eigenvalue was complex, generate a pair of eigenvectors */
	mk_DOUBLE_complex_array_conjugate_pair(c, r, n);
	c += 2*n;
	r += 2*n;
	iter += 2;
	}
	}
	}


	static inline void
	process_dgeev_results(GEEV_PARAMS_t *params)
	{
	/* REAL versions of geev need the results to be translated
	* into complex versions. This is the way to deal with imaginary
	* results. In our gufuncs we will always return complex arrays!
	*/
	mk_DOUBLE_complex_array(params->W, params->WR, params->WI, params->N);

	/* handle the eigenvectors */
	if ('V' == params->JOBVL) {
	mk_dgeev_complex_eigenvectors(params->VL, params->VLR,
	params->WI, params->N);
	}
	if ('V' == params->JOBVR) {
	mk_dgeev_complex_eigenvectors(params->VR, params->VRR,
	params->WI, params->N);
	}
	}




	#line 2113

	static inline int
	init_cgeev(GEEV_PARAMS_t* params,
	char jobvl,
	char jobvr,
	fortran_int n)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_uint8 a, w, vl, vr, work, rwork;
	size_t a_size = nnsizeof(fortran_complex);
	size_t w_size = n*sizeof(fortran_complex);
	size_t vl_size = jobvl=='V'? nnsizeof(fortran_complex) : 0;
	size_t vr_size = jobvr=='V'? nnsizeof(fortran_complex) : 0;
	size_t rwork_size = 2nsizeof(float);
	size_t work_count = 0;
	COMPLEX_t work_size_query;
	fortran_int do_size_query = -1;
	fortran_int rv;
	size_t total_size = a_size + w_size + vl_size + vr_size + rwork_size;

	mem_buff = malloc(total_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	w = a + a_size;
	vl = w + w_size;
	vr = vl + vl_size;
	rwork = vr + vr_size;
	LAPACK(cgeev)(&jobvl, &jobvr, &n,
	(void )a, &n, (void )w,
	(void )vl, &n, (void )vr, &n,
	(void *)&work_size_query, &do_size_query,
	(void *)rwork,
	&rv);
	if (0 != rv)
	goto error;

	work_count = (size_t) work_size_query.array[0];
	mem_buff2 = malloc(work_count*sizeof(fortran_complex));
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->A = a;
	params->WR = rwork;
	params->WI = NULL;
	params->VLR = NULL;
	params->VRR = NULL;
	params->VL = vl;
	params->VR = vr;
	params->WORK = work;
	params->W = w;
	params->N = n;
	params->LDA = n;
	params->LDVL = n;
	params->LDVR = n;
	params->LWORK = (fortran_int)work_count;
	params->JOBVL = jobvl;
	params->JOBVR = jobvr;

	return 1;
	error:
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_cgeev(GEEV_PARAMS_t* params)
	{
	fortran_int rv;

	LAPACK(cgeev)(&params->JOBVL, &params->JOBVR,
	&params->N, params->A, &params->LDA,
	params->W,
	params->VL, &params->LDVL,
	params->VR, &params->LDVR,
	params->WORK, &params->LWORK,
	params->WR, /* actually RWORK */
	&rv);
	return rv;
	}


	static inline void
	process_cgeev_results(GEEV_PARAMS_t *NPY_UNUSED(params))
	{
	/* nothing to do here, complex versions are ready to copy out */
	}

	#line 2113

	static inline int
	init_zgeev(GEEV_PARAMS_t* params,
	char jobvl,
	char jobvr,
	fortran_int n)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_uint8 a, w, vl, vr, work, rwork;
	size_t a_size = nnsizeof(fortran_doublecomplex);
	size_t w_size = n*sizeof(fortran_doublecomplex);
	size_t vl_size = jobvl=='V'? nnsizeof(fortran_doublecomplex) : 0;
	size_t vr_size = jobvr=='V'? nnsizeof(fortran_doublecomplex) : 0;
	size_t rwork_size = 2nsizeof(double);
	size_t work_count = 0;
	DOUBLECOMPLEX_t work_size_query;
	fortran_int do_size_query = -1;
	fortran_int rv;
	size_t total_size = a_size + w_size + vl_size + vr_size + rwork_size;

	mem_buff = malloc(total_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	w = a + a_size;
	vl = w + w_size;
	vr = vl + vl_size;
	rwork = vr + vr_size;
	LAPACK(zgeev)(&jobvl, &jobvr, &n,
	(void )a, &n, (void )w,
	(void )vl, &n, (void )vr, &n,
	(void *)&work_size_query, &do_size_query,
	(void *)rwork,
	&rv);
	if (0 != rv)
	goto error;

	work_count = (size_t) work_size_query.array[0];
	mem_buff2 = malloc(work_count*sizeof(fortran_doublecomplex));
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->A = a;
	params->WR = rwork;
	params->WI = NULL;
	params->VLR = NULL;
	params->VRR = NULL;
	params->VL = vl;
	params->VR = vr;
	params->WORK = work;
	params->W = w;
	params->N = n;
	params->LDA = n;
	params->LDVL = n;
	params->LDVR = n;
	params->LWORK = (fortran_int)work_count;
	params->JOBVL = jobvl;
	params->JOBVR = jobvr;

	return 1;
	error:
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_zgeev(GEEV_PARAMS_t* params)
	{
	fortran_int rv;

	LAPACK(zgeev)(&params->JOBVL, &params->JOBVR,
	&params->N, params->A, &params->LDA,
	params->W,
	params->VL, &params->LDVL,
	params->VR, &params->LDVR,
	params->WORK, &params->LWORK,
	params->WR, /* actually RWORK */
	&rv);
	return rv;
	}


	static inline void
	process_zgeev_results(GEEV_PARAMS_t *NPY_UNUSED(params))
	{
	/* nothing to do here, complex versions are ready to copy out */
	}



	#line 2216

	static inline void
	release_sgeev(GEEV_PARAMS_t *params)
	{
	free(params->WORK);
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	FLOAT_eig_wrapper(char JOBVL,
	char JOBVR,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = 2;
	int error_occurred = get_fp_invalid_and_clear();
	GEEV_PARAMS_t geev_params;

	assert(JOBVL == 'N');

	STACK_TRACE;
	op_count += 'V'==JOBVL?1:0;
	op_count += 'V'==JOBVR?1:0;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_sgeev(&geev_params,
	JOBVL, JOBVR,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t a_in;
	LINEARIZE_DATA_t w_out;
	LINEARIZE_DATA_t vl_out;
	LINEARIZE_DATA_t vr_out;

	init_linearize_data(&a_in,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	init_linearize_data(&w_out,
	1, geev_params.N,
	0, steps[0]);
	steps += 1;
	if ('V' == geev_params.JOBVL) {
	init_linearize_data(&vl_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	}
	if ('V' == geev_params.JOBVR) {
	init_linearize_data(&vr_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	char **arg_iter = args;
	/* copy the matrix in */
	linearize_FLOAT_matrix(geev_params.A, *arg_iter++, &a_in);
	not_ok = call_sgeev(&geev_params);

	if (!not_ok) {
	process_sgeev_results(&geev_params);
	delinearize_CFLOAT_matrix(*arg_iter++,
	geev_params.W,
	&w_out);

	if ('V' == geev_params.JOBVL)
	delinearize_CFLOAT_matrix(*arg_iter++,
	geev_params.VL,
	&vl_out);
	if ('V' == geev_params.JOBVR)
	delinearize_CFLOAT_matrix(*arg_iter++,
	geev_params.VR,
	&vr_out);
	} else {
	/* geev failed */
	error_occurred = 1;
	nan_CFLOAT_matrix(*arg_iter++, &w_out);
	if ('V' == geev_params.JOBVL)
	nan_CFLOAT_matrix(*arg_iter++, &vl_out);
	if ('V' == geev_params.JOBVR)
	nan_CFLOAT_matrix(*arg_iter++, &vr_out);
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_sgeev(&geev_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	FLOAT_eig(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_eig_wrapper('N', 'V', args, dimensions, steps);
	}

	static void
	FLOAT_eigvals(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_eig_wrapper('N', 'N', args, dimensions, steps);
	}


	#line 2216

	static inline void
	release_dgeev(GEEV_PARAMS_t *params)
	{
	free(params->WORK);
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	DOUBLE_eig_wrapper(char JOBVL,
	char JOBVR,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = 2;
	int error_occurred = get_fp_invalid_and_clear();
	GEEV_PARAMS_t geev_params;

	assert(JOBVL == 'N');

	STACK_TRACE;
	op_count += 'V'==JOBVL?1:0;
	op_count += 'V'==JOBVR?1:0;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_dgeev(&geev_params,
	JOBVL, JOBVR,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t a_in;
	LINEARIZE_DATA_t w_out;
	LINEARIZE_DATA_t vl_out;
	LINEARIZE_DATA_t vr_out;

	init_linearize_data(&a_in,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	init_linearize_data(&w_out,
	1, geev_params.N,
	0, steps[0]);
	steps += 1;
	if ('V' == geev_params.JOBVL) {
	init_linearize_data(&vl_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	}
	if ('V' == geev_params.JOBVR) {
	init_linearize_data(&vr_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	char **arg_iter = args;
	/* copy the matrix in */
	linearize_DOUBLE_matrix(geev_params.A, *arg_iter++, &a_in);
	not_ok = call_dgeev(&geev_params);

	if (!not_ok) {
	process_dgeev_results(&geev_params);
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.W,
	&w_out);

	if ('V' == geev_params.JOBVL)
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.VL,
	&vl_out);
	if ('V' == geev_params.JOBVR)
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.VR,
	&vr_out);
	} else {
	/* geev failed */
	error_occurred = 1;
	nan_CDOUBLE_matrix(*arg_iter++, &w_out);
	if ('V' == geev_params.JOBVL)
	nan_CDOUBLE_matrix(*arg_iter++, &vl_out);
	if ('V' == geev_params.JOBVR)
	nan_CDOUBLE_matrix(*arg_iter++, &vr_out);
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_dgeev(&geev_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	DOUBLE_eig(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_eig_wrapper('N', 'V', args, dimensions, steps);
	}

	static void
	DOUBLE_eigvals(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_eig_wrapper('N', 'N', args, dimensions, steps);
	}


	#line 2216

	static inline void
	release_zgeev(GEEV_PARAMS_t *params)
	{
	free(params->WORK);
	free(params->A);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	CDOUBLE_eig_wrapper(char JOBVL,
	char JOBVR,
	char**args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = 2;
	int error_occurred = get_fp_invalid_and_clear();
	GEEV_PARAMS_t geev_params;

	assert(JOBVL == 'N');

	STACK_TRACE;
	op_count += 'V'==JOBVL?1:0;
	op_count += 'V'==JOBVR?1:0;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_zgeev(&geev_params,
	JOBVL, JOBVR,
	(fortran_int)dimensions[0])) {
	LINEARIZE_DATA_t a_in;
	LINEARIZE_DATA_t w_out;
	LINEARIZE_DATA_t vl_out;
	LINEARIZE_DATA_t vr_out;

	init_linearize_data(&a_in,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	init_linearize_data(&w_out,
	1, geev_params.N,
	0, steps[0]);
	steps += 1;
	if ('V' == geev_params.JOBVL) {
	init_linearize_data(&vl_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	steps += 2;
	}
	if ('V' == geev_params.JOBVR) {
	init_linearize_data(&vr_out,
	geev_params.N, geev_params.N,
	steps[1], steps[0]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	char **arg_iter = args;
	/* copy the matrix in */
	linearize_CDOUBLE_matrix(geev_params.A, *arg_iter++, &a_in);
	not_ok = call_zgeev(&geev_params);

	if (!not_ok) {
	process_zgeev_results(&geev_params);
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.W,
	&w_out);

	if ('V' == geev_params.JOBVL)
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.VL,
	&vl_out);
	if ('V' == geev_params.JOBVR)
	delinearize_CDOUBLE_matrix(*arg_iter++,
	geev_params.VR,
	&vr_out);
	} else {
	/* geev failed */
	error_occurred = 1;
	nan_CDOUBLE_matrix(*arg_iter++, &w_out);
	if ('V' == geev_params.JOBVL)
	nan_CDOUBLE_matrix(*arg_iter++, &vl_out);
	if ('V' == geev_params.JOBVR)
	nan_CDOUBLE_matrix(*arg_iter++, &vr_out);
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_zgeev(&geev_params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}

	static void
	CDOUBLE_eig(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_eig_wrapper('N', 'V', args, dimensions, steps);
	}

	static void
	CDOUBLE_eigvals(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_eig_wrapper('N', 'N', args, dimensions, steps);
	}




	/* -------------------------------------------------------------------------- */
	/* singular value decomposition */

	typedef struct gessd_params_struct
	{
	void *A;
	void *S;
	void *U;
	void *VT;
	void *WORK;
	void *RWORK;
	void *IWORK;

	fortran_int M;
	fortran_int N;
	fortran_int LDA;
	fortran_int LDU;
	fortran_int LDVT;
	fortran_int LWORK;
	char JOBZ;
	} GESDD_PARAMS_t;


	static inline void
	dump_gesdd_params(const char *name,
	GESDD_PARAMS_t *params)
	{
	TRACE_TXT("\n%s:\n"\

	"%14s: %18p\n"\
	"%14s: %18p\n"\
	"%14s: %18p\n"\
	"%14s: %18p\n"\
	"%14s: %18p\n"\
	"%14s: %18p\n"\
	"%14s: %18p\n"\

	"%14s: %18d\n"\
	"%14s: %18d\n"\
	"%14s: %18d\n"\
	"%14s: %18d\n"\
	"%14s: %18d\n"\
	"%14s: %18d\n"\

	"%14s: %15c'%c'\n",

	name,

	"A", params->A,
	"S", params->S,
	"U", params->U,
	"VT", params->VT,
	"WORK", params->WORK,
	"RWORK", params->RWORK,
	"IWORK", params->IWORK,

	"M", (int)params->M,
	"N", (int)params->N,
	"LDA", (int)params->LDA,
	"LDU", (int)params->LDU,
	"LDVT", (int)params->LDVT,
	"LWORK", (int)params->LWORK,

	"JOBZ", ' ',params->JOBZ);
	}

	static inline int
	compute_urows_vtcolumns(char jobz,
	fortran_int m, fortran_int n,
	fortran_int urows, fortran_int vtcolumns)
	{
	fortran_int min_m_n = m<n?m:n;
	switch(jobz)
	{
	case 'N':
	*urows = 0;
	*vtcolumns = 0;
	break;
	case 'A':
	*urows = m;
	*vtcolumns = n;
	break;
	case 'S':
	{
	*urows = min_m_n;
	*vtcolumns = min_m_n;
	}
	break;
	default:
	return 0;
	}

	return 1;
	}


	#line 2439

	static inline int
	init_sgesdd(GESDD_PARAMS_t *params,
	char jobz,
	fortran_int m,
	fortran_int n)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_uint8 a, s, u, vt, work, iwork;
	size_t a_size = (size_t)m(size_t)nsizeof(fortran_real);
	fortran_int min_m_n = m<n?m:n;
	size_t s_size = ((size_t)min_m_n)*sizeof(fortran_real);
	fortran_int u_row_count, vt_column_count;
	size_t u_size, vt_size;
	fortran_int work_count;
	size_t work_size;
	size_t iwork_size = 8((size_t)min_m_n)sizeof(fortran_int);

	if (!compute_urows_vtcolumns(jobz, m, n, &u_row_count, &vt_column_count))
	goto error;

	u_size = ((size_t)u_row_count)msizeof(fortran_real);
	vt_size = n((size_t)vt_column_count)sizeof(fortran_real);

	mem_buff = malloc(a_size + s_size + u_size + vt_size + iwork_size);

	if (!mem_buff)
	goto error;

	a = mem_buff;
	s = a + a_size;
	u = s + s_size;
	vt = u + u_size;
	iwork = vt + vt_size;

	/* fix vt_column_count so that it is a valid lapack parameter (0 is not) */
	vt_column_count = vt_column_count < 1? 1 : vt_column_count;
	{
	/* compute optimal work size */
	fortran_real work_size_query;
	fortran_int do_query = -1;
	fortran_int rv;
	LAPACK(sgesdd)(&jobz, &m, &n,
	(void)a, &m, (void)s, (void*)u, &m,
	(void*)vt, &vt_column_count,
	&work_size_query, &do_query,
	(void*)iwork, &rv);
	if (0!=rv)
	goto error;
	work_count = (fortran_int)work_size_query;
	work_size = (size_t)work_count * sizeof(fortran_real);
	}

	mem_buff2 = malloc(work_size);
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->M = m;
	params->N = n;
	params->A = a;
	params->S = s;
	params->U = u;
	params->VT = vt;
	params->WORK = work;
	params->RWORK = NULL;
	params->IWORK = iwork;
	params->M = m;
	params->N = n;
	params->LDA = m;
	params->LDU = m;
	params->LDVT = vt_column_count;
	params->LWORK = work_count;
	params->JOBZ = jobz;

	return 1;
	error:
	TRACE_TXT("%s failed init\n", __FUNCTION__);
	free(mem_buff);
	free(mem_buff2);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_sgesdd(GESDD_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(sgesdd)(&params->JOBZ, &params->M, &params->N,
	params->A, &params->LDA,
	params->S,
	params->U, &params->LDU,
	params->VT, &params->LDVT,
	params->WORK, &params->LWORK,
	params->IWORK,
	&rv);
	return rv;
	}


	#line 2439

	static inline int
	init_dgesdd(GESDD_PARAMS_t *params,
	char jobz,
	fortran_int m,
	fortran_int n)
	{
	npy_uint8 *mem_buff = NULL;
	npy_uint8 *mem_buff2 = NULL;
	npy_uint8 a, s, u, vt, work, iwork;
	size_t a_size = (size_t)m(size_t)nsizeof(fortran_doublereal);
	fortran_int min_m_n = m<n?m:n;
	size_t s_size = ((size_t)min_m_n)*sizeof(fortran_doublereal);
	fortran_int u_row_count, vt_column_count;
	size_t u_size, vt_size;
	fortran_int work_count;
	size_t work_size;
	size_t iwork_size = 8((size_t)min_m_n)sizeof(fortran_int);

	if (!compute_urows_vtcolumns(jobz, m, n, &u_row_count, &vt_column_count))
	goto error;

	u_size = ((size_t)u_row_count)msizeof(fortran_doublereal);
	vt_size = n((size_t)vt_column_count)sizeof(fortran_doublereal);

	mem_buff = malloc(a_size + s_size + u_size + vt_size + iwork_size);

	if (!mem_buff)
	goto error;

	a = mem_buff;
	s = a + a_size;
	u = s + s_size;
	vt = u + u_size;
	iwork = vt + vt_size;

	/* fix vt_column_count so that it is a valid lapack parameter (0 is not) */
	vt_column_count = vt_column_count < 1? 1 : vt_column_count;
	{
	/* compute optimal work size */
	fortran_doublereal work_size_query;
	fortran_int do_query = -1;
	fortran_int rv;
	LAPACK(dgesdd)(&jobz, &m, &n,
	(void)a, &m, (void)s, (void*)u, &m,
	(void*)vt, &vt_column_count,
	&work_size_query, &do_query,
	(void*)iwork, &rv);
	if (0!=rv)
	goto error;
	work_count = (fortran_int)work_size_query;
	work_size = (size_t)work_count * sizeof(fortran_doublereal);
	}

	mem_buff2 = malloc(work_size);
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->M = m;
	params->N = n;
	params->A = a;
	params->S = s;
	params->U = u;
	params->VT = vt;
	params->WORK = work;
	params->RWORK = NULL;
	params->IWORK = iwork;
	params->M = m;
	params->N = n;
	params->LDA = m;
	params->LDU = m;
	params->LDVT = vt_column_count;
	params->LWORK = work_count;
	params->JOBZ = jobz;

	return 1;
	error:
	TRACE_TXT("%s failed init\n", __FUNCTION__);
	free(mem_buff);
	free(mem_buff2);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_dgesdd(GESDD_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(dgesdd)(&params->JOBZ, &params->M, &params->N,
	params->A, &params->LDA,
	params->S,
	params->U, &params->LDU,
	params->VT, &params->LDVT,
	params->WORK, &params->LWORK,
	params->IWORK,
	&rv);
	return rv;
	}



	#line 2550

	static inline int
	init_cgesdd(GESDD_PARAMS_t *params,
	char jobz,
	fortran_int m,
	fortran_int n)
	{
	npy_uint8 mem_buff = NULL, mem_buff2 = NULL;
	npy_uint8 a,s, u, vt, work, rwork, *iwork;
	size_t a_size, s_size, u_size, vt_size, work_size, rwork_size, iwork_size;
	fortran_int u_row_count, vt_column_count, work_count;
	fortran_int min_m_n = m<n?m:n;

	if (!compute_urows_vtcolumns(jobz, m, n, &u_row_count, &vt_column_count))
	goto error;

	a_size = ((size_t)m)((size_t)n)sizeof(fortran_complex);
	s_size = ((size_t)min_m_n)*sizeof(fortran_real);
	u_size = ((size_t)u_row_count)msizeof(fortran_complex);
	vt_size = n((size_t)vt_column_count)sizeof(fortran_complex);
	rwork_size = 'N'==jobz?
	7*((size_t)min_m_n) :
	(5(size_t)min_m_n(size_t)min_m_n + 5*(size_t)min_m_n);
	rwork_size *= sizeof(fortran_complex);
	iwork_size = 8((size_t)min_m_n)sizeof(fortran_int);

	mem_buff = malloc(a_size +
	s_size +
	u_size +
	vt_size +
	rwork_size +
	iwork_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	s = a + a_size;
	u = s + s_size;
	vt = u + u_size;
	rwork = vt + vt_size;
	iwork = rwork + rwork_size;

	/* fix vt_column_count so that it is a valid lapack parameter (0 is not) */
	vt_column_count = vt_column_count < 1? 1 : vt_column_count;
	{
	/* compute optimal work size */
	fortran_complex work_size_query;
	fortran_int do_query = -1;
	fortran_int rv;
	LAPACK(cgesdd)(&jobz, &m, &n,
	(void)a, &m, (void)s, (void*)u, &m,
	(void*)vt, &vt_column_count,
	&work_size_query, &do_query,
	(void*)rwork,
	(void*)iwork, &rv);
	if (0!=rv)
	goto error;
	work_count = (fortran_int)((COMPLEX_t*)&work_size_query)->array[0];
	work_size = (size_t)work_count * sizeof(fortran_complex);
	}

	mem_buff2 = malloc(work_size);
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->A = a;
	params->S = s;
	params->U = u;
	params->VT = vt;
	params->WORK = work;
	params->RWORK = rwork;
	params->IWORK = iwork;
	params->M = m;
	params->N = n;
	params->LDA = m;
	params->LDU = m;
	params->LDVT = vt_column_count;
	params->LWORK = work_count;
	params->JOBZ = jobz;

	return 1;
	error:
	TRACE_TXT("%s failed init\n", __FUNCTION__);
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_cgesdd(GESDD_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(cgesdd)(&params->JOBZ, &params->M, &params->N,
	params->A, &params->LDA,
	params->S,
	params->U, &params->LDU,
	params->VT, &params->LDVT,
	params->WORK, &params->LWORK,
	params->RWORK,
	params->IWORK,
	&rv);
	return rv;
	}

	#line 2550

	static inline int
	init_zgesdd(GESDD_PARAMS_t *params,
	char jobz,
	fortran_int m,
	fortran_int n)
	{
	npy_uint8 mem_buff = NULL, mem_buff2 = NULL;
	npy_uint8 a,s, u, vt, work, rwork, *iwork;
	size_t a_size, s_size, u_size, vt_size, work_size, rwork_size, iwork_size;
	fortran_int u_row_count, vt_column_count, work_count;
	fortran_int min_m_n = m<n?m:n;

	if (!compute_urows_vtcolumns(jobz, m, n, &u_row_count, &vt_column_count))
	goto error;

	a_size = ((size_t)m)((size_t)n)sizeof(fortran_doublecomplex);
	s_size = ((size_t)min_m_n)*sizeof(fortran_doublereal);
	u_size = ((size_t)u_row_count)msizeof(fortran_doublecomplex);
	vt_size = n((size_t)vt_column_count)sizeof(fortran_doublecomplex);
	rwork_size = 'N'==jobz?
	7*((size_t)min_m_n) :
	(5(size_t)min_m_n(size_t)min_m_n + 5*(size_t)min_m_n);
	rwork_size *= sizeof(fortran_doublecomplex);
	iwork_size = 8((size_t)min_m_n)sizeof(fortran_int);

	mem_buff = malloc(a_size +
	s_size +
	u_size +
	vt_size +
	rwork_size +
	iwork_size);
	if (!mem_buff)
	goto error;

	a = mem_buff;
	s = a + a_size;
	u = s + s_size;
	vt = u + u_size;
	rwork = vt + vt_size;
	iwork = rwork + rwork_size;

	/* fix vt_column_count so that it is a valid lapack parameter (0 is not) */
	vt_column_count = vt_column_count < 1? 1 : vt_column_count;
	{
	/* compute optimal work size */
	fortran_doublecomplex work_size_query;
	fortran_int do_query = -1;
	fortran_int rv;
	LAPACK(zgesdd)(&jobz, &m, &n,
	(void)a, &m, (void)s, (void*)u, &m,
	(void*)vt, &vt_column_count,
	&work_size_query, &do_query,
	(void*)rwork,
	(void*)iwork, &rv);
	if (0!=rv)
	goto error;
	work_count = (fortran_int)((DOUBLECOMPLEX_t*)&work_size_query)->array[0];
	work_size = (size_t)work_count * sizeof(fortran_doublecomplex);
	}

	mem_buff2 = malloc(work_size);
	if (!mem_buff2)
	goto error;

	work = mem_buff2;

	params->A = a;
	params->S = s;
	params->U = u;
	params->VT = vt;
	params->WORK = work;
	params->RWORK = rwork;
	params->IWORK = iwork;
	params->M = m;
	params->N = n;
	params->LDA = m;
	params->LDU = m;
	params->LDVT = vt_column_count;
	params->LWORK = work_count;
	params->JOBZ = jobz;

	return 1;
	error:
	TRACE_TXT("%s failed init\n", __FUNCTION__);
	free(mem_buff2);
	free(mem_buff);
	memset(params, 0, sizeof(*params));

	return 0;
	}

	static inline fortran_int
	call_zgesdd(GESDD_PARAMS_t *params)
	{
	fortran_int rv;
	LAPACK(zgesdd)(&params->JOBZ, &params->M, &params->N,
	params->A, &params->LDA,
	params->S,
	params->U, &params->LDU,
	params->VT, &params->LDVT,
	params->WORK, &params->LWORK,
	params->RWORK,
	params->IWORK,
	&rv);
	return rv;
	}



	#line 2665
	static inline void
	release_sgesdd(GESDD_PARAMS_t* params)
	{
	/* A and WORK contain allocated blocks */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	FLOAT_svd_wrapper(char JOBZ,
	char **args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	int error_occurred = get_fp_invalid_and_clear();
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:4;
	GESDD_PARAMS_t params;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_sgesdd(&params,
	JOBZ,
	(fortran_int)dimensions[0],
	(fortran_int)dimensions[1])) {
	LINEARIZE_DATA_t a_in, u_out, s_out, v_out;

	init_linearize_data(&a_in, params.N, params.M, steps[1], steps[0]);
	if ('N' == params.JOBZ) {
	/* only the singular values are wanted */
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	init_linearize_data(&s_out, 1, min_m_n, 0, steps[2]);
	} else {
	fortran_int u_columns, v_rows;
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	if ('S' == params.JOBZ) {
	u_columns = min_m_n;
	v_rows = min_m_n;
	} else {
	u_columns = params.M;
	v_rows = params.N;
	}
	init_linearize_data(&u_out,
	u_columns, params.M,
	steps[3], steps[2]);
	init_linearize_data(&s_out,
	1, min_m_n,
	0, steps[4]);
	init_linearize_data(&v_out,
	params.N, v_rows,
	steps[6], steps[5]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_FLOAT_matrix(params.A, args[0], &a_in);
	not_ok = call_sgesdd(&params);
	if (!not_ok) {
	if ('N' == params.JOBZ) {
	delinearize_FLOAT_matrix(args[1], params.S, &s_out);
	} else {
	delinearize_FLOAT_matrix(args[1], params.U, &u_out);
	delinearize_FLOAT_matrix(args[2], params.S, &s_out);
	delinearize_FLOAT_matrix(args[3], params.VT, &v_out);
	}
	} else {
	error_occurred = 1;
	if ('N' == params.JOBZ) {
	nan_FLOAT_matrix(args[1], &s_out);
	} else {
	nan_FLOAT_matrix(args[1], &u_out);
	nan_FLOAT_matrix(args[2], &s_out);
	nan_FLOAT_matrix(args[3], &v_out);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_sgesdd(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}
	/*end repeat/


	/* svd gufunc entry points */
	/**begin repeat
	#TYPE=FLOAT,DOUBLE,CFLOAT,CDOUBLE#
	*/
	static void
	FLOAT_svd_N(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_svd_wrapper('N', args, dimensions, steps);
	}

	static void
	FLOAT_svd_S(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_svd_wrapper('S', args, dimensions, steps);
	}

	static void
	FLOAT_svd_A(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	FLOAT_svd_wrapper('A', args, dimensions, steps);
	}


	#line 2665
	static inline void
	release_dgesdd(GESDD_PARAMS_t* params)
	{
	/* A and WORK contain allocated blocks */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	DOUBLE_svd_wrapper(char JOBZ,
	char **args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	int error_occurred = get_fp_invalid_and_clear();
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:4;
	GESDD_PARAMS_t params;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_dgesdd(&params,
	JOBZ,
	(fortran_int)dimensions[0],
	(fortran_int)dimensions[1])) {
	LINEARIZE_DATA_t a_in, u_out, s_out, v_out;

	init_linearize_data(&a_in, params.N, params.M, steps[1], steps[0]);
	if ('N' == params.JOBZ) {
	/* only the singular values are wanted */
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	init_linearize_data(&s_out, 1, min_m_n, 0, steps[2]);
	} else {
	fortran_int u_columns, v_rows;
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	if ('S' == params.JOBZ) {
	u_columns = min_m_n;
	v_rows = min_m_n;
	} else {
	u_columns = params.M;
	v_rows = params.N;
	}
	init_linearize_data(&u_out,
	u_columns, params.M,
	steps[3], steps[2]);
	init_linearize_data(&s_out,
	1, min_m_n,
	0, steps[4]);
	init_linearize_data(&v_out,
	params.N, v_rows,
	steps[6], steps[5]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_DOUBLE_matrix(params.A, args[0], &a_in);
	not_ok = call_dgesdd(&params);
	if (!not_ok) {
	if ('N' == params.JOBZ) {
	delinearize_DOUBLE_matrix(args[1], params.S, &s_out);
	} else {
	delinearize_DOUBLE_matrix(args[1], params.U, &u_out);
	delinearize_DOUBLE_matrix(args[2], params.S, &s_out);
	delinearize_DOUBLE_matrix(args[3], params.VT, &v_out);
	}
	} else {
	error_occurred = 1;
	if ('N' == params.JOBZ) {
	nan_DOUBLE_matrix(args[1], &s_out);
	} else {
	nan_DOUBLE_matrix(args[1], &u_out);
	nan_DOUBLE_matrix(args[2], &s_out);
	nan_DOUBLE_matrix(args[3], &v_out);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_dgesdd(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}
	/*end repeat/


	/* svd gufunc entry points */
	/**begin repeat
	#TYPE=FLOAT,DOUBLE,CFLOAT,CDOUBLE#
	*/
	static void
	DOUBLE_svd_N(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_svd_wrapper('N', args, dimensions, steps);
	}

	static void
	DOUBLE_svd_S(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_svd_wrapper('S', args, dimensions, steps);
	}

	static void
	DOUBLE_svd_A(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	DOUBLE_svd_wrapper('A', args, dimensions, steps);
	}


	#line 2665
	static inline void
	release_cgesdd(GESDD_PARAMS_t* params)
	{
	/* A and WORK contain allocated blocks */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	CFLOAT_svd_wrapper(char JOBZ,
	char **args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	int error_occurred = get_fp_invalid_and_clear();
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:4;
	GESDD_PARAMS_t params;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_cgesdd(&params,
	JOBZ,
	(fortran_int)dimensions[0],
	(fortran_int)dimensions[1])) {
	LINEARIZE_DATA_t a_in, u_out, s_out, v_out;

	init_linearize_data(&a_in, params.N, params.M, steps[1], steps[0]);
	if ('N' == params.JOBZ) {
	/* only the singular values are wanted */
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	init_linearize_data(&s_out, 1, min_m_n, 0, steps[2]);
	} else {
	fortran_int u_columns, v_rows;
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	if ('S' == params.JOBZ) {
	u_columns = min_m_n;
	v_rows = min_m_n;
	} else {
	u_columns = params.M;
	v_rows = params.N;
	}
	init_linearize_data(&u_out,
	u_columns, params.M,
	steps[3], steps[2]);
	init_linearize_data(&s_out,
	1, min_m_n,
	0, steps[4]);
	init_linearize_data(&v_out,
	params.N, v_rows,
	steps[6], steps[5]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_CFLOAT_matrix(params.A, args[0], &a_in);
	not_ok = call_cgesdd(&params);
	if (!not_ok) {
	if ('N' == params.JOBZ) {
	delinearize_FLOAT_matrix(args[1], params.S, &s_out);
	} else {
	delinearize_CFLOAT_matrix(args[1], params.U, &u_out);
	delinearize_FLOAT_matrix(args[2], params.S, &s_out);
	delinearize_CFLOAT_matrix(args[3], params.VT, &v_out);
	}
	} else {
	error_occurred = 1;
	if ('N' == params.JOBZ) {
	nan_FLOAT_matrix(args[1], &s_out);
	} else {
	nan_CFLOAT_matrix(args[1], &u_out);
	nan_FLOAT_matrix(args[2], &s_out);
	nan_CFLOAT_matrix(args[3], &v_out);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_cgesdd(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}
	/*end repeat/


	/* svd gufunc entry points */
	/**begin repeat
	#TYPE=FLOAT,DOUBLE,CFLOAT,CDOUBLE#
	*/
	static void
	CFLOAT_svd_N(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CFLOAT_svd_wrapper('N', args, dimensions, steps);
	}

	static void
	CFLOAT_svd_S(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CFLOAT_svd_wrapper('S', args, dimensions, steps);
	}

	static void
	CFLOAT_svd_A(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CFLOAT_svd_wrapper('A', args, dimensions, steps);
	}


	#line 2665
	static inline void
	release_zgesdd(GESDD_PARAMS_t* params)
	{
	/* A and WORK contain allocated blocks */
	free(params->A);
	free(params->WORK);
	memset(params, 0, sizeof(*params));
	}

	static inline void
	CDOUBLE_svd_wrapper(char JOBZ,
	char **args,
	npy_intp* dimensions,
	npy_intp* steps)
	{
	ptrdiff_t outer_steps[4];
	int error_occurred = get_fp_invalid_and_clear();
	size_t iter;
	size_t outer_dim = *dimensions++;
	size_t op_count = (JOBZ=='N')?2:4;
	GESDD_PARAMS_t params;

	for (iter=0; iter < op_count; ++iter) {
	outer_steps[iter] = (ptrdiff_t) steps[iter];
	}
	steps += op_count;

	if (init_zgesdd(&params,
	JOBZ,
	(fortran_int)dimensions[0],
	(fortran_int)dimensions[1])) {
	LINEARIZE_DATA_t a_in, u_out, s_out, v_out;

	init_linearize_data(&a_in, params.N, params.M, steps[1], steps[0]);
	if ('N' == params.JOBZ) {
	/* only the singular values are wanted */
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	init_linearize_data(&s_out, 1, min_m_n, 0, steps[2]);
	} else {
	fortran_int u_columns, v_rows;
	fortran_int min_m_n = params.M < params.N? params.M : params.N;
	if ('S' == params.JOBZ) {
	u_columns = min_m_n;
	v_rows = min_m_n;
	} else {
	u_columns = params.M;
	v_rows = params.N;
	}
	init_linearize_data(&u_out,
	u_columns, params.M,
	steps[3], steps[2]);
	init_linearize_data(&s_out,
	1, min_m_n,
	0, steps[4]);
	init_linearize_data(&v_out,
	params.N, v_rows,
	steps[6], steps[5]);
	}

	for (iter = 0; iter < outer_dim; ++iter) {
	int not_ok;
	/* copy the matrix in */
	linearize_CDOUBLE_matrix(params.A, args[0], &a_in);
	not_ok = call_zgesdd(&params);
	if (!not_ok) {
	if ('N' == params.JOBZ) {
	delinearize_DOUBLE_matrix(args[1], params.S, &s_out);
	} else {
	delinearize_CDOUBLE_matrix(args[1], params.U, &u_out);
	delinearize_DOUBLE_matrix(args[2], params.S, &s_out);
	delinearize_CDOUBLE_matrix(args[3], params.VT, &v_out);
	}
	} else {
	error_occurred = 1;
	if ('N' == params.JOBZ) {
	nan_DOUBLE_matrix(args[1], &s_out);
	} else {
	nan_CDOUBLE_matrix(args[1], &u_out);
	nan_DOUBLE_matrix(args[2], &s_out);
	nan_CDOUBLE_matrix(args[3], &v_out);
	}
	}
	update_pointers((npy_uint8**)args, outer_steps, op_count);
	}

	release_zgesdd(&params);
	}

	set_fp_invalid_or_clear(error_occurred);
	}
	/*end repeat/


	/* svd gufunc entry points */
	/**begin repeat
	#TYPE=FLOAT,DOUBLE,CFLOAT,CDOUBLE#
	*/
	static void
	CDOUBLE_svd_N(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_svd_wrapper('N', args, dimensions, steps);
	}

	static void
	CDOUBLE_svd_S(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_svd_wrapper('S', args, dimensions, steps);
	}

	static void
	CDOUBLE_svd_A(char **args,
	npy_intp *dimensions,
	npy_intp *steps,
	void *NPY_UNUSED(func))
	{
	CDOUBLE_svd_wrapper('A', args, dimensions, steps);
	}



	#pragma GCC diagnostic pop

	/* -------------------------------------------------------------------------- */
	/* gufunc registration */

	static void *array_of_nulls[] = {
	(void *)NULL,
	(void *)NULL,
	(void *)NULL,
	(void *)NULL,

	(void *)NULL,
	(void *)NULL,
	(void *)NULL,
	(void *)NULL,

	(void *)NULL,
	(void *)NULL,
	(void *)NULL,
	(void *)NULL,

	(void *)NULL,
	(void *)NULL,
	(void *)NULL,
	(void *)NULL
	};

	#define FUNC_ARRAY_NAME(NAME) NAME ## _funcs

	#define GUFUNC_FUNC_ARRAY_REAL(NAME) \
	static PyUFuncGenericFunction \
	FUNC_ARRAY_NAME(NAME)[] = { \
	FLOAT_ ## NAME, \
	DOUBLE_ ## NAME \
	}

	#define GUFUNC_FUNC_ARRAY_REAL_COMPLEX(NAME) \
	static PyUFuncGenericFunction \
	FUNC_ARRAY_NAME(NAME)[] = { \
	FLOAT_ ## NAME, \
	DOUBLE_ ## NAME, \
	CFLOAT_ ## NAME, \
	CDOUBLE_ ## NAME \
	}

	/* There are problems with eig in complex single precision.
	* That kernel is disabled
	*/
	#define GUFUNC_FUNC_ARRAY_EIG(NAME) \
	static PyUFuncGenericFunction \
	FUNC_ARRAY_NAME(NAME)[] = { \
	FLOAT_ ## NAME, \
	DOUBLE_ ## NAME, \
	CDOUBLE_ ## NAME \
	}


	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(slogdet);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(det);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eighlo);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eighup);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eigvalshlo);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(eigvalshup);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(solve);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(solve1);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(inv);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(cholesky_lo);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_N);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_S);
	GUFUNC_FUNC_ARRAY_REAL_COMPLEX(svd_A);
	GUFUNC_FUNC_ARRAY_EIG(eig);
	GUFUNC_FUNC_ARRAY_EIG(eigvals);

	static char equal_2_types[] = {
	NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_CFLOAT,
	NPY_CDOUBLE, NPY_CDOUBLE
	};

	static char equal_3_types[] = {
	NPY_FLOAT, NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_CFLOAT, NPY_CFLOAT,
	NPY_CDOUBLE, NPY_CDOUBLE, NPY_CDOUBLE
	};

	/* second result is logdet, that will always be a REAL */
	static char slogdet_types[] = {
	NPY_FLOAT, NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_CFLOAT, NPY_FLOAT,
	NPY_CDOUBLE, NPY_CDOUBLE, NPY_DOUBLE
	};

	static char eigh_types[] = {
	NPY_FLOAT, NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_FLOAT, NPY_CFLOAT,
	NPY_CDOUBLE, NPY_DOUBLE, NPY_CDOUBLE
	};

	static char eighvals_types[] = {
	NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_FLOAT,
	NPY_CDOUBLE, NPY_DOUBLE
	};

	static char eig_types[] = {
	NPY_FLOAT, NPY_CFLOAT, NPY_CFLOAT,
	NPY_DOUBLE, NPY_CDOUBLE, NPY_CDOUBLE,
	NPY_CDOUBLE, NPY_CDOUBLE, NPY_CDOUBLE
	};

	static char eigvals_types[] = {
	NPY_FLOAT, NPY_CFLOAT,
	NPY_DOUBLE, NPY_CDOUBLE,
	NPY_CDOUBLE, NPY_CDOUBLE
	};

	static char svd_1_1_types[] = {
	NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_FLOAT,
	NPY_CDOUBLE, NPY_DOUBLE
	};

	static char svd_1_3_types[] = {
	NPY_FLOAT, NPY_FLOAT, NPY_FLOAT, NPY_FLOAT,
	NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE,
	NPY_CFLOAT, NPY_CFLOAT, NPY_FLOAT, NPY_CFLOAT,
	NPY_CDOUBLE, NPY_CDOUBLE, NPY_DOUBLE, NPY_CDOUBLE
	};

	typedef struct gufunc_descriptor_struct {
	char *name;
	char *signature;
	char *doc;
	int ntypes;
	int nin;
	int nout;
	PyUFuncGenericFunction *funcs;
	char *types;
	} GUFUNC_DESCRIPTOR_t;

	GUFUNC_DESCRIPTOR_t gufunc_descriptors [] = {
	{
	"slogdet",
	"(m,m)->(),()",
	"slogdet on the last two dimensions and broadcast on the rest. \n"\
	"Results in two arrays, one with sign and the other with log of the"\
	" determinants. \n"\
	" \"(m,m)->(),()\" \n",
	4, 1, 2,
	FUNC_ARRAY_NAME(slogdet),
	slogdet_types
	},
	{
	"det",
	"(m,m)->()",
	"det of the last two dimensions and broadcast on the rest. \n"\
	" \"(m,m)->()\" \n",
	4, 1, 1,
	FUNC_ARRAY_NAME(det),
	equal_2_types
	},
	{
	"eigh_lo",
	"(m,m)->(m),(m,m)",
	"eigh on the last two dimension and broadcast to the rest, using"\
	" lower triangle \n"\
	"Results in a vector of eigenvalues and a matrix with the"\
	"eigenvectors. \n"\
	" \"(m,m)->(m),(m,m)\" \n",
	4, 1, 2,
	FUNC_ARRAY_NAME(eighlo),
	eigh_types
	},
	{
	"eigh_up",
	"(m,m)->(m),(m,m)",
	"eigh on the last two dimension and broadcast to the rest, using"\
	" upper triangle. \n"\
	"Results in a vector of eigenvalues and a matrix with the"\
	" eigenvectors. \n"\
	" \"(m,m)->(m),(m,m)\" \n",
	4, 1, 2,
	FUNC_ARRAY_NAME(eighup),
	eigh_types
	},
	{
	"eigvalsh_lo",
	"(m,m)->(m)",
	"eigh on the last two dimension and broadcast to the rest, using"\
	" lower triangle. \n"\
	"Results in a vector of eigenvalues and a matrix with the"\
	"eigenvectors. \n"\
	" \"(m,m)->(m)\" \n",
	4, 1, 1,
	FUNC_ARRAY_NAME(eigvalshlo),
	eighvals_types
	},
	{
	"eigvalsh_up",
	"(m,m)->(m)",
	"eigvalsh on the last two dimension and broadcast to the rest,"\
	" using upper triangle. \n"\
	"Results in a vector of eigenvalues and a matrix with the"\
	"eigenvectors.\n"\
	" \"(m,m)->(m)\" \n",
	4, 1, 1,
	FUNC_ARRAY_NAME(eigvalshup),
	eighvals_types
	},
	{
	"solve",
	"(m,m),(m,n)->(m,n)",
	"solve the system a x = b, on the last two dimensions, broadcast"\
	" to the rest. \n"\
	"Results in a matrices with the solutions. \n"\
	" \"(m,m),(m,n)->(m,n)\" \n",
	4, 2, 1,
	FUNC_ARRAY_NAME(solve),
	equal_3_types
	},
	{
	"solve1",
	"(m,m),(m)->(m)",
	"solve the system a x = b, for b being a vector, broadcast in"\
	" the outer dimensions. \n"\
	"Results in vectors with the solutions. \n"\
	" \"(m,m),(m)->(m)\" \n",
	4,2,1,
	FUNC_ARRAY_NAME(solve1),
	equal_3_types
	},
	{
	"inv",
	"(m,m)->(m,m)",
	"compute the inverse of the last two dimensions and broadcast"\
	" to the rest. \n"\
	"Results in the inverse matrices. \n"\
	" \"(m,m)->(m,m)\" \n",
	4,1,1,
	FUNC_ARRAY_NAME(inv),
	equal_2_types
	},
	{
	"cholesky_lo",
	"(m,m)->(m,m)",
	"cholesky decomposition of hermitian positive-definite matrices. \n"\
	"Broadcast to all outer dimensions. \n"\
	" \"(m,m)->(m,m)\" \n",
	4, 1, 1,
	FUNC_ARRAY_NAME(cholesky_lo),
	equal_2_types
	},
	{
	"svd_m",
	"(m,n)->(m)",
	"svd when n>=m. ",
	4, 1, 1,
	FUNC_ARRAY_NAME(svd_N),
	svd_1_1_types
	},
	{
	"svd_n",
	"(m,n)->(n)",
	"svd when n<=m",
	4, 1, 1,
	FUNC_ARRAY_NAME(svd_N),
	svd_1_1_types
	},
	{
	"svd_m_s",
	"(m,n)->(m,m),(m),(m,n)",
	"svd when m>=n",
	4, 1, 3,
	FUNC_ARRAY_NAME(svd_S),
	svd_1_3_types
	},
	{
	"svd_n_s",
	"(m,n)->(m,n),(n),(n,n)",
	"svd when m>=n",
	4, 1, 3,
	FUNC_ARRAY_NAME(svd_S),
	svd_1_3_types
	},
	{
	"svd_m_f",
	"(m,n)->(m,m),(m),(n,n)",
	"svd when m>=n",
	4, 1, 3,
	FUNC_ARRAY_NAME(svd_A),
	svd_1_3_types
	},
	{
	"svd_n_f",
	"(m,n)->(m,m),(n),(n,n)",
	"svd when m>=n",
	4, 1, 3,
	FUNC_ARRAY_NAME(svd_A),
	svd_1_3_types
	},
	{
	"eig",
	"(m,m)->(m),(m,m)",
	"eig on the last two dimension and broadcast to the rest. \n"\
	"Results in a vector with the eigenvalues and a matrix with the"\
	" eigenvectors. \n"\
	" \"(m,m)->(m),(m,m)\" \n",
	3, 1, 2,
	FUNC_ARRAY_NAME(eig),
	eig_types
	},
	{
	"eigvals",
	"(m,m)->(m)",
	"eigvals on the last two dimension and broadcast to the rest. \n"\
	"Results in a vector of eigenvalues. \n"\
	" \"(m,m)->(m),(m,m)\" \n",
	3, 1, 1,
	FUNC_ARRAY_NAME(eigvals),
	eigvals_types
	},
	};

	static void
	addUfuncs(PyObject *dictionary) {
	PyObject *f;
	int i;
	const int gufunc_count = sizeof(gufunc_descriptors)/
	sizeof(gufunc_descriptors[0]);
	for (i=0; i < gufunc_count; i++) {
	GUFUNC_DESCRIPTOR_t* d = &gufunc_descriptors[i];
	f = PyUFunc_FromFuncAndDataAndSignature(d->funcs,
	array_of_nulls,
	d->types,
	d->ntypes,
	d->nin,
	d->nout,
	PyUFunc_None,
	d->name,
	d->doc,
	0,
	d->signature);
	PyDict_SetItemString(dictionary, d->name, f);
	#if 0
	dump_ufunc_object((PyUFuncObject*) f);
	#endif
	Py_DECREF(f);
	}
	}



	/* -------------------------------------------------------------------------- */
	/* Module initialization stuff */

	static PyMethodDef UMath_LinAlgMethods[] = {
	{NULL, NULL, 0, NULL} /* Sentinel */
	};

	#if defined(NPY_PY3K)
	static struct PyModuleDef moduledef = {
	PyModuleDef_HEAD_INIT,
	UMATH_LINALG_MODULE_NAME,
	NULL,
	-1,
	UMath_LinAlgMethods,
	NULL,
	NULL,
	NULL,
	NULL
	};
	#endif

	#if defined(NPY_PY3K)
	#define RETVAL m
	PyObject *PyInit__umath_linalg(void)
	#else
	#define RETVAL
	PyMODINIT_FUNC
	init_umath_linalg(void)
	#endif
	{
	PyObject *m;
	PyObject *d;
	PyObject *version;

	init_constants();
	#if defined(NPY_PY3K)
	m = PyModule_Create(&moduledef);
	#else
	m = Py_InitModule(UMATH_LINALG_MODULE_NAME, UMath_LinAlgMethods);
	#endif
	if (m == NULL)
	return RETVAL;

	import_array();
	import_ufunc();

	d = PyModule_GetDict(m);

	version = PyString_FromString(umath_linalg_version_string);
	PyDict_SetItemString(d, "__version__", version);
	Py_DECREF(version);

	/* Load the ufunc operators into the module's namespace */
	addUfuncs(d);

	if (PyErr_Occurred()) {
	PyErr_SetString(PyExc_RuntimeError,
	"cannot load _umath_linalg module.");
	}

	return RETVAL;
	}