PyObject* dotu(PyObject *self, PyObject *args)
{
PyArrayObject* a;
PyArrayObject* b;
if (!PyArg_ParseTuple(args, "OO", &a, &b))
return NULL;
int n = PyArray_DIMS(a)[0];
for (int i = 1; i < PyArray_NDIM(a); i++)
n *= PyArray_DIMS(a)[i];
int incx = 1;
int incy = 1;
if (PyArray_DESCR(a)->type_num == NPY_DOUBLE)
{
double result;
result = ddot_(&n, (void*)DOUBLEP(a),
&incx, (void*)DOUBLEP(b), &incy);
return PyFloat_FromDouble(result);
}
else
{
double_complex* ap = COMPLEXP(a);
double_complex* bp = COMPLEXP(b);
double_complex z = 0.0;
for (int i = 0; i < n; i++)
z += ap[i] * bp[i];
return PyComplex_FromDoubles(creal(z), cimag(z));
}
}
/*
* This function returns a NEW reference, i.e. caller must decref it in the end.
*/
PyObject* JySync_Init_PyComplex_From_JyComplex(jobject src, PyTypeObject* nonNativeSubtype)
{
env(NULL);
return PyComplex_FromDoubles(
(double) (*env)->GetDoubleField(env, src, pyComplexRealField),
(double) (*env)->GetDoubleField(env, src, pyComplexImagField));
}
void makeComplexList(double2* array_in, int list_size, PyObject *list_out) {
if (!PyList_Check(list_out)) fprintf(stderr,"makeComplexList must take "
"a Python list\n");
int q;
for (q=0;q<list_size;q++) {
PyList_Append(list_out, PyComplex_FromDoubles(array_in[q].x, array_in[q].y));
}
}
static PyObject *
nu_complex_float(const char *p, const formatdef *f)
{
float re, im;
memcpy((char *)&re, p, sizeof re);
memcpy((char *)&im, p+sizeof re, sizeof im);
return PyComplex_FromDoubles((double)re, (double) im);
}
static PyObject *
nu_complex_double(const char *p, const formatdef *f)
{
double re, im;
memcpy((char *)&re, p, sizeof re);
memcpy((char *)&im, p+sizeof re, sizeof im);
return PyComplex_FromDoubles(re, im);
}
inline PyObject* ComplexVector_to_python(ComplexVector* cpp) {
PyObject* py = PyList_New(cpp->size());
for (size_t i = 0; i < cpp->size(); ++i) {
ComplexPixel& px = (*cpp)[i];
PyObject* complex = PyComplex_FromDoubles(px.real(), px.imag());
PyList_SET_ITEM(py, i, complex);
}
return py;
}
static PyObject *
GMPy_PyComplex_From_MPC(PyObject *self, PyObject *other)
{
CTXT_Object *context = NULL;
double real, imag;
CHECK_CONTEXT(context);
real = mpfr_get_d(mpc_realref(MPC(self)), GET_REAL_ROUND(context));
imag = mpfr_get_d(mpc_imagref(MPC(self)), GET_IMAG_ROUND(context));
return PyComplex_FromDoubles(real, imag);
}
PyObject *cvcopyToList_f(vsip_cvview_f *v){
PyObject *cval;
vsip_length N = vsip_cvgetlength_f(v);
PyObject *retval = PyList_New(N);
vsip_index i;
for(i=0; i<N; i++){
vsip_cscalar_f x = vsip_cvget_f(v,i);
double re = (double)x.r;
double im = (double)x.i;
cval = PyComplex_FromDoubles(re,im);
PyList_SetItem(retval,i,cval);
}
return retval;
}
static PyObject *
PyResponse_eval_response(PyResponse *self, PyObject *args)
{
double omega, real, imag;
PyObject *result;
if (! PyArg_ParseTuple(args, "d", &omega))
return NULL;
if (eval_response(omega, self->response, &real, &imag) != 0)
return NULL;
result = PyComplex_FromDoubles(real, imag);
if (result == NULL)
return NULL;
return result;
}
/* hread supports reading of header items of all types using the various
* hread_c calls. Reads one item per call. */
PyObject * WRAP_hread(PyObject *self, PyObject *args) {
int item_hdl, offset, iostat;
char *type;
PyObject *val, *rv;
int in; short sh; long lg; float fl; double db; float cx[2]; char st[2];
if (!PyArg_ParseTuple(args, "iis", &item_hdl, &offset, &type))
return NULL;
try {
switch (type[0]) {
case 'a':
hreadb_c(item_hdl, st, offset, H_BYTE_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("si", st, H_BYTE_SIZE);
case 'i':
hreadi_c(item_hdl, &in, offset, H_INT_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("ii", in, H_INT_SIZE);
case 'j':
hreadj_c(item_hdl, &sh, offset, H_INT2_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("ii", sh, H_INT2_SIZE);
case 'l':
hreadl_c(item_hdl, &lg, offset, H_INT8_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("li", lg, H_INT8_SIZE);
case 'r':
hreadr_c(item_hdl, &fl, offset, H_REAL_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("fi", fl, H_REAL_SIZE);
case 'd':
hreadd_c(item_hdl, &db, offset, H_DBLE_SIZE, &iostat);
CHK_IO(iostat);
return Py_BuildValue("fi", db, H_DBLE_SIZE);
case 'c':
hreadc_c(item_hdl, cx, offset, H_CMPLX_SIZE, &iostat);
CHK_IO(iostat);
val = PyComplex_FromDoubles((double) cx[0], (double) cx[1]);
rv = Py_BuildValue("Oi", val, H_CMPLX_SIZE);
Py_DECREF(val);
return rv;
default:
PyErr_Format(PyExc_ValueError, "unknown item type: %c",type[0]);
return NULL;
}
} catch (MiriadError &e) {
PyErr_Format(PyExc_RuntimeError, e.get_message());
return NULL;
}
}
void PyComplex(char *name, double value, double value2)
{
PyObject *obj;
obj = PyComplex_FromDoubles(value, value2);
if(list_level>=0 && List[list_level]) {
PyList_Append(List[list_level], obj);
Py_DECREF(obj);
return;
}
PyObject_SetAttrString(interpreter_state->main_module, name, obj);
Py_DECREF(obj);
}
/* rdvr is responsible for reading variables of all types. It wraps the
* output of uvgetvr_c into various python structures, and returns
* arrays as numpy arrays. */
PyObject * UVObject_rdvr(UVObject *self, PyObject *args) {
char *name, *type, value[MAXVAR];
int length, updated;
npy_intp dims[1];
PyArrayObject *rv;
if (!PyArg_ParseTuple(args, "ss", &name, &type)) return NULL;
uvprobvr_c(self->tno, name, value, &length, &updated);
dims[0] = length;
try {
switch (type[0]) {
case 'a':
uvgetvr_c(self->tno,H_BYTE,name,value,length+1);
return PyString_FromStringAndSize(value, length);
case 'j':
uvgetvr_c(self->tno,H_INT2,name,value,length);
if (length == 1)
return PyInt_FromLong((long) ((short *)value)[0]);
rv = (PyArrayObject *) PyArray_SimpleNew(1, dims, PyArray_INT);
CHK_NULL(rv);
for (int i=0; i < length; i++)
IND1(rv,i,int) = ((short *)value)[i];
return PyArray_Return(rv);
case 'i':
RET_IA(H_INT,PyInt_FromLong,long,int,PyArray_INT);
case 'r':
RET_IA(H_REAL,PyFloat_FromDouble,double,float,PyArray_FLOAT);
case 'd':
RET_IA(H_DBLE,PyFloat_FromDouble,double,double,PyArray_DOUBLE);
case 'c':
if (length == 1) {
uvgetvr_c(self->tno,H_CMPLX,name,value,length);
return PyComplex_FromDoubles(((double *)value)[0],
((double *)value)[1]);
}
rv = (PyArrayObject *) PyArray_SimpleNew(1,dims,PyArray_CDOUBLE);
CHK_NULL(rv);
uvgetvr_c(self->tno,H_CMPLX,name,(char *)rv->data,length);
return PyArray_Return(rv);
default:
PyErr_Format(PyExc_ValueError,"unknown var type: %c",type[0]);
return NULL;
}
} catch (MiriadError &e) {
PyErr_Format(PyExc_RuntimeError, e.get_message());
return NULL;
}
}
PyObject *cmcopyToListByCol_d(vsip_cmview_d *v){
PyObject *cval;
vsip_length M = vsip_cmgetcollength_d(v);
vsip_length N = vsip_cmgetrowlength_d(v);
PyObject *retval = PyList_New(M);
vsip_index i,j;
for(j=0; j<N; j++){
PyObject *col = PyList_New(M);
for(i=0; i<M; i++){
vsip_cscalar_d x = vsip_cmget_d(v,i,j);
double re = (double)x.r;
double im = (double)x.i;
cval = PyComplex_FromDoubles(re,im);
PyList_SetItem(col,i,cval);
}
PyList_SetItem(retval,j,col);
}
return retval;
}
inline PyObject* pixel_to_python(ComplexPixel px) {
return PyComplex_FromDoubles(px.real(), px.imag());
}
//---------------------------------------------------------------------------
PyObject* ToPyObject(const Func32::TComplex &Value)
{
return Value.imag() ? PyComplex_FromDoubles(Value.real(), Value.imag()) : PyFloat_FromDouble(Value.real());
}
static int int2_coerce(PyObject **pv, PyObject **pw)
{
if (PgInt2_Check(*pv))
{
if (PyInt_Check(*pw))
{
*pv = Py_BuildValue("h", PgInt2_AS_INT2(*pv));
Py_INCREF(*pw);
}
#if defined(HAVE_LONG_LONG_SUPPORT)
else if (PgInt8_Check(*pw))
{
*pv = (PyObject *)PgInt8_FromLong((long)PgInt2_AS_INT2(*pv));
Py_INCREF(*pw);
}
#endif
else if (PyLong_Check(*pw))
{
*pv = (PyObject *)PyLong_FromLong((long)PgInt2_AS_INT2(*pv));
Py_INCREF(*pw);
}
else if (PyFloat_Check(*pw))
{
*pv = Py_BuildValue("d", (double)PgInt2_AS_INT2(*pv));
Py_INCREF(*pw);
}
else if (PyComplex_Check(*pw))
{
*pv = (PyObject *)PyComplex_FromDoubles(
(double)PgInt2_AS_INT2(*pv), (double)0);
Py_INCREF(*pw);
}
else
return 1;
return 0;
}
else if (PgInt2_Check(*pw)) {
if (PyInt_Check(*pv))
{
*pw = Py_BuildValue("h", PgInt2_AS_INT2(*pw));
Py_INCREF(*pv);
}
#if defined(HAVE_LONG_LONG_SUPPORT)
else if (PgInt8_Check(*pv))
{
*pw = (PyObject *)PgInt8_FromLong((long)PgInt2_AS_INT2(*pw));
Py_INCREF(*pv);
}
#endif
else if (PyLong_Check(*pv))
{
*pw = (PyObject *)PyLong_FromLong((long)PgInt2_AS_INT2(*pw));
Py_INCREF(*pw);
}
else if (PyFloat_Check(*pv))
{
*pw = Py_BuildValue("d", (double)PgInt2_AS_INT2(*pw));
Py_INCREF(*pw);
}
else if (PyComplex_Check(*pv))
{
*pw = (PyObject *)PyComplex_FromDoubles(
(double)PgInt2_AS_INT2(*pw), (double)0);
Py_INCREF(*pv);
}
else
return 1;
return 0;
}
return 1; /* Can't do it */
}
/* NOTE: R vectors of length 1 will yield a python list of length 1*/
int
to_Pyobj_vector(SEXP robj, PyObject **obj, int mode)
{
PyObject *it, *tmp;
SEXP names, dim;
int len, *integers, i, type;
const char *strings, *thislevel;
double *reals;
Rcomplex *complexes;
#ifdef WITH_NUMERIC
PyObject *array;
#endif
if (!robj)
{
// return -1; /* error */
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "robj does not exist"));
// PyObject_CallObject(my_callback, argslist);
// }
return 1;
}
if (robj == R_NilValue) {
Py_INCREF(Py_None);
*obj = Py_None;
return 1; /* succeed */
}
len = GET_LENGTH(robj);
tmp = PyList_New(len);
type = TYPEOF(robj);
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(si)", "robj length is ", len));
// PyObject_CallObject(my_callback, argslist);
// }
/// break for checking the R length and other aspects
for (i=0; i<len; i++) {
switch (type)
{
case LGLSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In LGLSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
integers = INTEGER(robj);
if(integers[i]==NA_INTEGER) /* watch out for NA's */
{
if (!(it = PyInt_FromLong(integers[i])))
//return -1;
tmp = Py_BuildValue("s", "failed in the PyInt_FromLong"); // we are at least getting an robj
*obj = tmp;
return 1;
//it = Py_None;
}
else if (!(it = PyBool_FromLong(integers[i])))
{
tmp = Py_BuildValue("s", "failed in the PyBool_FromLong"); // we are at least getting an robj
*obj = tmp;
return 1;
//return -1;
}
break;
case INTSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In INTSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
integers = INTEGER(robj);
if(isFactor(robj)) {
/* Watch for NA's! */
if(integers[i]==NA_INTEGER)
it = PyString_FromString(CHAR(NA_STRING));
else
{
thislevel = CHAR(STRING_ELT(GET_LEVELS(robj), integers[i]-1));
if (!(it = PyString_FromString(thislevel)))
{
tmp = Py_BuildValue("s", "failed in the PyString_FromString"); // we are at least getting an robj
*obj = tmp;
return 1;
}
//return -1;
}
}
else {
if (!(it = PyInt_FromLong(integers[i])))
{
tmp = Py_BuildValue("s", "failed in the PyInt_FromLong"); // we are at least getting an robj
*obj = tmp;
return 1;
//return -1;
}
}
break;
case REALSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In REALSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
reals = REAL(robj);
if (!(it = PyFloat_FromDouble(reals[i])))
{
// tmp = Py_BuildValue("s", "failed in the PyFloat_FromDouble"); // we are at least getting an robj
// *obj = tmp;
// return 1;
return -1;
}
break;
case CPLXSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In CPLXSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
complexes = COMPLEX(robj);
if (!(it = PyComplex_FromDoubles(complexes[i].r,
complexes[i].i)))
{
// tmp = Py_BuildValue("s", "failed in PyComplex_FromDoubles!!!"); // we are at least getting an robj
// *obj = tmp;
// return 1;
return -1;
}
break;
case STRSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In STRSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
if(STRING_ELT(robj, i)==R_NaString)
it = PyString_FromString(CHAR(NA_STRING));
else
{
strings = CHAR(STRING_ELT(robj, i));
if (!(it = PyString_FromString(strings)))
{
// tmp = Py_BuildValue("s", "failed in PyString_FromString!!!"); // we are at least getting an robj
// *obj = tmp;
// return 1;
return -1;
}
}
break;
case LISTSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In LISTSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
if (!(it = to_Pyobj_with_mode(elt(robj, i), mode)))
{
// tmp = Py_BuildValue("s", "failed in to_Pyobj_with_mode LISTSXP!!!"); // we are at least getting an robj
// *obj = tmp;
// return 1;
return -1;
}
break;
case VECSXP:
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In VECSXP"));
// PyObject_CallObject(my_callback, argslist);
// }
if (!(it = to_Pyobj_with_mode(VECTOR_ELT(robj, i), mode)))
{
return -1;
}
break;
default:
Py_DECREF(tmp);
return 0; /* failed */
}
if (PyList_SetItem(tmp, i, it) < 0) // there was a failure in setting the item
{
// tmp = Py_BuildValue("s", "failed in PyList_SetItem!!!"); // we are at least getting an robj
// *obj = tmp;
// return 1;
return -1;
}
}
dim = GET_DIM(robj);
if (dim != R_NilValue) {
// #ifdef WITH_NUMERIC
// if(use_numeric)
// {
// array = to_PyNumericArray(tmp, dim);
// if (array) { /* If the conversion to Numeric succeed.. */
// *obj = array; /* we are done */
// Py_DECREF(tmp);
// return 1;
// }
// PyErr_Clear();
// }
// #endif
len = GET_LENGTH(dim);
*obj = to_PyArray(tmp, INTEGER(dim), len);
Py_DECREF(tmp);
return 1;
}
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(O)", tmp));
// PyObject_CallObject(my_callback, argslist);
// }
names = GET_NAMES(robj);
if (names == R_NilValue)
{
*obj = tmp;
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "returning as list (of lists)"));
// PyObject_CallObject(my_callback, argslist);
// }
}
else {
*obj = to_PyDict(tmp, names);
// if(my_callback){
// argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "returning as dict"));
// PyObject_CallObject(my_callback, argslist);
// }
Py_DECREF(tmp);
}
return 1;
}
static PyObject *c2py(std::complex<double> x) { return PyComplex_FromDoubles(x.real(), x.imag()); }
template<> PyObject *__to_py(complex c) {
return PyComplex_FromDoubles(c.real, c.imag);
}
