static PyObject *
lapack_lite_zungqr(PyObject *NPY_UNUSED(self), PyObject *args)
{
int lapack_lite_status;
int m, n, k, lwork;
PyObject *a, *tau, *work;
int lda;
int info;
TRY(PyArg_ParseTuple(args,"iiiOiOOii", &m, &n, &k, &a, &lda, &tau, &work, &lwork, &info));
TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zungqr"));
TRY(check_object(tau,NPY_CDOUBLE,"tau","NPY_CDOUBLE","zungqr"));
TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zungqr"));
lapack_lite_status =
FNAME(zungqr)(&m, &n, &k, ZDATA(a), &lda, ZDATA(tau), ZDATA(work),
&lwork, &info);
if (PyErr_Occurred()) {
return NULL;
}
return Py_BuildValue("{s:i,s:i}","zungqr_",lapack_lite_status,
"info",info);
}
static PyObject *
lapack_lite_zgeqrf(PyObject *NPY_UNUSED(self), PyObject *args)
{
int lapack_lite_status;
int m, n, lwork;
PyObject *a, *tau, *work;
int lda;
int info;
TRY(PyArg_ParseTuple(args,"iiOiOOii",&m,&n,&a,&lda,&tau,&work,&lwork,&info));
/* check objects and convert to right storage order */
TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgeqrf"));
TRY(check_object(tau,NPY_CDOUBLE,"tau","NPY_CDOUBLE","zgeqrf"));
TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgeqrf"));
lapack_lite_status =
FNAME(zgeqrf)(&m, &n, ZDATA(a), &lda, ZDATA(tau), ZDATA(work),
&lwork, &info);
if (PyErr_Occurred()) {
return NULL;
}
return Py_BuildValue("{s:i,s:i,s:i,s:i,s:i,s:i}","zgeqrf_",lapack_lite_status,"m",m,"n",n,"lda",lda,"lwork",lwork,"info",info);
}
static int64_t common_seek(SDL_RWops *rw, int64_t offset, int whence) {
if(!offset && whence == RW_SEEK_CUR) {
return ZDATA(rw)->pos;
}
return SDL_SetError("Can't seek in %s stream", TYPENAME(rw));
}
static int common_close(SDL_RWops *rw) {
PRINT("common_close\n");
if(rw) {
ZData *z = ZDATA(rw);
PRINT("T = %i\n", z->type);
if(z->type == TYPE_DEFLATE) {
deflate_flush(z);
deflateEnd(z->stream);
free(z->buffer_aux);
} else {
inflateEnd(z->stream);
}
free(z->buffer);
free(z->stream);
if(z->autoclose) {
SDL_RWclose(z->wrapped);
}
free(z);
SDL_FreeRW(rw);
}
return 0;
}
static size_t deflate_write(SDL_RWops *rw, const void *ptr, size_t size, size_t maxnum) {
ZData *z = ZDATA(rw);
size_t totalsize = size * maxnum;
size_t available;
size_t remaining = totalsize;
size_t offset = 0;
while(remaining) {
available = z->buffer_size - (z->buffer_ptr - z->buffer);
size_t copysize = remaining > available ? available : remaining;
PRINT("avail = %lu; copysize = %lu\n", available, copysize);
if(available) {
remaining -= copysize;
memcpy(z->buffer_ptr, (uint8_t*)ptr + offset, copysize);
printbuf(z->buffer_ptr, copysize);
offset += copysize;
z->buffer_ptr += copysize;
z->pos += copysize;
} else {
deflate_flush(z);
}
}
return maxnum;
}
static PyObject *
lapack_lite_zgelsd(PyObject *NPY_UNUSED(self), PyObject *args)
{
int lapack_lite_status;
int m;
int n;
int nrhs;
PyObject *a;
int lda;
PyObject *b;
int ldb;
PyObject *s;
double rcond;
int rank;
PyObject *work;
int lwork;
PyObject *rwork;
PyObject *iwork;
int info;
TRY(PyArg_ParseTuple(args,"iiiOiOiOdiOiOOi",
&m,&n,&nrhs,&a,&lda,&b,&ldb,&s,&rcond,
&rank,&work,&lwork,&rwork,&iwork,&info));
TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgelsd"));
TRY(check_object(b,NPY_CDOUBLE,"b","NPY_CDOUBLE","zgelsd"));
TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","zgelsd"));
TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgelsd"));
TRY(check_object(rwork,NPY_DOUBLE,"rwork","NPY_DOUBLE","zgelsd"));
TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","zgelsd"));
lapack_lite_status =
FNAME(zgelsd)(&m,&n,&nrhs,ZDATA(a),&lda,ZDATA(b),&ldb,DDATA(s),&rcond,
&rank,ZDATA(work),&lwork,DDATA(rwork),IDATA(iwork),&info);
if (PyErr_Occurred()) {
return NULL;
}
return Py_BuildValue("{s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i,s:i}","zgelsd_",
lapack_lite_status,"m",m,"n",n,"nrhs",nrhs,"lda",lda,
"ldb",ldb,"rank",rank,"lwork",lwork,"info",info);
}
SDL_RWops* SDL_RWWrapZReader(SDL_RWops *src, size_t bufsize, bool autoclose) {
if(!src) {
return NULL;
}
SDL_RWops *rw = common_alloc(src, bufsize, autoclose);
if(!rw) {
return NULL;
}
rw->read = inflate_read;
rw->write = inflate_write;
ZData *z = ZDATA(rw);
z->type = TYPE_INFLATE;
inflateInit(ZDATA(rw)->stream);
return rw;
}
static size_t inflate_read(SDL_RWops *rw, void *ptr, size_t size, size_t maxnum) {
ZData *z = ZDATA(rw);
size_t totalsize = size * maxnum;
int ret = Z_OK;
if(!totalsize) {
return 0;
}
z->stream->avail_out = totalsize;
z->stream->next_out = ptr;
PRINT("inflate_read()\n");
while(z->stream->avail_out && ret != Z_STREAM_END) {
z->stream->avail_in = z->buffer_fillsize - (z->buffer_ptr - z->buffer);
if(!z->stream->avail_in) {
z->buffer_fillsize = SDL_RWread(z->wrapped, z->buffer, 1, z->buffer_size);
z->buffer_ptr = z->buffer;
z->stream->avail_in = z->buffer_fillsize - (z->buffer_ptr - z->buffer);
}
z->stream->next_in = z->buffer_ptr;
PRINT(" -- begin read %i --- \n", z->stream->avail_in);
printbuf(z->stream->next_in, z->stream->avail_in);
PRINT(" -- end read --- \n");
switch(ret = inflate(z->stream, Z_NO_FLUSH)) {
case Z_OK:
case Z_STREAM_END:
PRINT("read ok\n");
break;
default:
PRINT("inflate error: %i\n", ret);
SDL_SetError("inflate error: %i", ret);
ret = Z_STREAM_END;
break;
}
z->buffer_ptr = z->stream->next_in;
}
z->pos += (totalsize - z->stream->avail_out);
return (totalsize - z->stream->avail_out) / size;
}
SDL_RWops* SDL_RWWrapZWriter(SDL_RWops *src, size_t bufsize, bool autoclose) {
if(!src) {
return NULL;
}
SDL_RWops *rw = common_alloc(src, bufsize, autoclose);
if(!rw) {
return NULL;
}
rw->read = deflate_read;
rw->write = deflate_write;
ZData *z = ZDATA(rw);
z->type = TYPE_DEFLATE;
z->buffer_aux_size = z->buffer_size;
z->buffer_aux = calloc(1, z->buffer_aux_size);
deflateInit(z->stream, Z_DEFAULT_COMPRESSION);
return rw;
}
z_stream* SDL_RWGetZStream(SDL_RWops *rw) {
return ZDATA(rw)->stream;
}