static int SpiDev_set_max_speed_hz(SpiDevObject *self, PyObject *val, void *closure) { uint32_t max_speed_hz; if (val == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { max_speed_hz = PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { max_speed_hz = PyLong_AS_LONG(val); } else { PyErr_SetString(PyExc_TypeError, "The max_speed_hz attribute must be an integer"); return -1; } } if (self->max_speed_hz != max_speed_hz) { if (ioctl(self->fd, SPI_IOC_WR_MAX_SPEED_HZ, &max_speed_hz) == -1) { PyErr_SetFromErrno(PyExc_IOError); return -1; } self->max_speed_hz = max_speed_hz; } return 0; }
/* * private helper function: convert an integer list to union i2c_smbus_data */ static int SMBus_list_to_data(PyObject *list, union i2c_smbus_data *data) { static char *msg = "Third argument must be a list of at least one, " "but not more than 32 integers"; int ii, len; if (!PyList_Check(list)) { PyErr_SetString(PyExc_TypeError, msg); return 0; /* fail */ } if ((len = PyList_GET_SIZE(list)) > 32) { PyErr_SetString(PyExc_OverflowError, msg); return 0; /* fail */ } /* first byte is the length */ data->block[0] = (__u8)len; for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); if (!PyLong_Check(val)) { PyErr_SetString(PyExc_TypeError, msg); return 0; /* fail */ } data->block[ii+1] = (__u8)PyLong_AS_LONG(val); } return 1; /* success */ }
static inline long pyint_as_long(PyObject*s) { #ifdef PYTHON3 return PyLong_AS_LONG(s); #else return PyInt_AS_LONG(s); #endif }
static PyObject * SpiDev_writebytes(SpiDevObject *self, PyObject *args) { int status; uint16_t ii, len; uint8_t buf[SPIDEV_MAXPATH]; PyObject *list; char wrmsg_text[4096]; if (!PyArg_ParseTuple(args, "O!:write", &PyList_Type, &list)) return NULL; if (PyList_Size(list) <= 0) { PyErr_SetString(PyExc_TypeError, wrmsg_list0); return NULL; } if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) { snprintf(wrmsg_text, sizeof (wrmsg_text) - 1, wrmsg_listmax, SPIDEV_MAXPATH); PyErr_SetString(PyExc_OverflowError, wrmsg_text); return NULL; } for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { buf[ii] = (__u8)PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { buf[ii] = (__u8)PyLong_AS_LONG(val); } else { snprintf(wrmsg_text, sizeof (wrmsg_text) - 1, wrmsg_val, val); PyErr_SetString(PyExc_TypeError, wrmsg_text); return NULL; } } } status = write(self->fd, &buf[0], len); if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } if (status != len) { perror("short write"); return NULL; } Py_INCREF(Py_None); return Py_None; }
void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data) { #if PY_VERSION_HEX >= 0x03000000 T x = static_cast<T>(PyLong_AS_LONG(obj)); #else T x = static_cast<T>(PyInt_AS_LONG(obj)); #endif void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes; new (storage) T(x); data->convertible = storage; }
static PyObject * SpiDev_writebytes(SpiDevObject *self, PyObject *args) { int status; uint16_t ii, len; uint8_t buf[SPIDEV_MAXPATH]; PyObject *list; if (!PyArg_ParseTuple(args, "O:write", &list)) return NULL; if (!PyList_Check(list)) { PyErr_SetString(PyExc_TypeError, wrmsg); return NULL; } if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) { PyErr_SetString(PyExc_OverflowError, wrmsg); return NULL; } for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); if (!PyLong_Check(val)) { PyErr_SetString(PyExc_TypeError, wrmsg); return NULL; } buf[ii] = (__u8)PyLong_AS_LONG(val); } status = write(self->fd, &buf[0], len); if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } if (status != len) { perror("short write"); return NULL; } Py_INCREF(Py_None); return Py_None; }
static PyObject * grp_getgrgid(PyObject *self, PyObject *pyo_id) { PyObject *py_int_id; unsigned int gid; struct group *p; py_int_id = PyNumber_Long(pyo_id); if (!py_int_id) return NULL; gid = PyLong_AS_LONG(py_int_id); Py_DECREF(py_int_id); if ((p = getgrgid(gid)) == NULL) { PyErr_Format(PyExc_KeyError, "getgrgid(): gid not found: %d", gid); return NULL; } return mkgrent(p); }
static int SpiDev_set_mode(SpiDevObject *self, PyObject *val, void *closure) { uint8_t mode, tmp; if (val == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { mode = PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { mode = PyLong_AS_LONG(val); } else { PyErr_SetString(PyExc_TypeError, "The mode attribute must be an integer"); return -1; } } if ( mode > 3 ) { PyErr_SetString(PyExc_TypeError, "The mode attribute must be an integer" "between 0 and 3."); return -1; } // clean and set CPHA and CPOL bits tmp = ( self->mode & ~(SPI_CPHA | SPI_CPOL) ) | mode ; __spidev_set_mode(self->fd, tmp); self->mode = tmp; return 0; }
static int SpiDev_set_bits_per_word(SpiDevObject *self, PyObject *val, void *closure) { uint8_t bits; if (val == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { bits = PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { bits = PyLong_AS_LONG(val); } else { PyErr_SetString(PyExc_TypeError, "The bits_per_word attribute must be an integer"); return -1; } } if (bits < 8 || bits > 16) { PyErr_SetString(PyExc_TypeError, "invalid bits_per_word (8 to 16)"); return -1; } if (self->bits_per_word != bits) { if (ioctl(self->fd, SPI_IOC_WR_BITS_PER_WORD, &bits) == -1) { PyErr_SetFromErrno(PyExc_IOError); return -1; } self->bits_per_word = bits; } return 0; }
static PyObject * c_set(void *ptr, PyObject *value, Py_ssize_t size) { if (PyUnicode_Check(value)) { value = PyUnicode_AsEncodedString(value, _ctypes_conversion_encoding, _ctypes_conversion_errors); if (value == NULL) return NULL; if (PyBytes_GET_SIZE(value) != 1) { Py_DECREF(value); goto error; } *(char *)ptr = PyBytes_AS_STRING(value)[0]; Py_DECREF(value); _RET(value); } if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) { *(char *)ptr = PyBytes_AS_STRING(value)[0]; _RET(value); } if (PyByteArray_Check(value) && PyByteArray_GET_SIZE(value) == 1) { *(char *)ptr = PyByteArray_AS_STRING(value)[0]; _RET(value); } if (PyLong_Check(value)) { long longval = PyLong_AS_LONG(value); if (longval < 0 || longval >= 256) goto error; *(char *)ptr = (char)longval; _RET(value); } error: PyErr_Format(PyExc_TypeError, "one character string expected"); return NULL; }
static PyObject * c_set(void *ptr, PyObject *value, Py_ssize_t size) { if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) { *(char *)ptr = PyBytes_AS_STRING(value)[0]; _RET(value); } if (PyByteArray_Check(value) && PyByteArray_GET_SIZE(value) == 1) { *(char *)ptr = PyByteArray_AS_STRING(value)[0]; _RET(value); } if (PyLong_Check(value)) { long longval = PyLong_AS_LONG(value); if (longval < 0 || longval >= 256) goto error; *(char *)ptr = (char)longval; _RET(value); } error: PyErr_Format(PyExc_TypeError, "one character string expected"); return NULL; }
static PyObject * SpiDev_xfer2(SpiDevObject *self, PyObject *args) { int status; uint16_t delay_usecs = 0; uint32_t speed_hz = 0; uint8_t bits_per_word = 0; uint16_t ii, len; PyObject *obj; PyObject *seq; struct spi_ioc_transfer xfer; Py_BEGIN_ALLOW_THREADS memset(&xfer, 0, sizeof(xfer)); Py_END_ALLOW_THREADS uint8_t *txbuf, *rxbuf; char wrmsg_text[4096]; if (!PyArg_ParseTuple(args, "O|IHB:xfer2", &obj, &speed_hz, &delay_usecs, &bits_per_word)) return NULL; seq = PySequence_Fast(obj, "expected a sequence"); len = PySequence_Fast_GET_SIZE(seq); if (!seq || len <= 0) { PyErr_SetString(PyExc_TypeError, wrmsg_list0); return NULL; } if (len > SPIDEV_MAXPATH) { snprintf(wrmsg_text, sizeof(wrmsg_text) - 1, wrmsg_listmax, SPIDEV_MAXPATH); PyErr_SetString(PyExc_OverflowError, wrmsg_text); return NULL; } Py_BEGIN_ALLOW_THREADS txbuf = malloc(sizeof(__u8) * len); rxbuf = malloc(sizeof(__u8) * len); Py_END_ALLOW_THREADS for (ii = 0; ii < len; ii++) { PyObject *val = PySequence_Fast_GET_ITEM(seq, ii); #if PY_MAJOR_VERSION < 3 if (PyInt_Check(val)) { txbuf[ii] = (__u8)PyInt_AS_LONG(val); } else #endif { if (PyLong_Check(val)) { txbuf[ii] = (__u8)PyLong_AS_LONG(val); } else { snprintf(wrmsg_text, sizeof (wrmsg_text) - 1, wrmsg_val, val); PyErr_SetString(PyExc_TypeError, wrmsg_text); free(txbuf); free(rxbuf); return NULL; } } } if (PyTuple_Check(obj)) { Py_DECREF(seq); seq = PySequence_List(obj); } Py_BEGIN_ALLOW_THREADS xfer.tx_buf = (unsigned long)txbuf; xfer.rx_buf = (unsigned long)rxbuf; xfer.len = len; xfer.delay_usecs = delay_usecs; xfer.speed_hz = speed_hz ? speed_hz : self->max_speed_hz; xfer.bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word; status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer); Py_END_ALLOW_THREADS if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); free(txbuf); free(rxbuf); return NULL; } for (ii = 0; ii < len; ii++) { PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]); PySequence_SetItem(seq, ii, val); } // WA: // in CS_HIGH mode CS isnt pulled to low after transfer // reading 0 bytes doesn't really matter but brings CS down // tomdean: // Stop generating an extra CS except in mode CS_HOGH if (self->mode & SPI_CS_HIGH) status = read(self->fd, &rxbuf[0], 0); Py_BEGIN_ALLOW_THREADS free(txbuf); free(rxbuf); Py_END_ALLOW_THREADS if (PyTuple_Check(obj)) { PyObject *old = seq; seq = PySequence_Tuple(seq); Py_DECREF(old); } return seq; }
int PyPath_Flatten(PyObject* data, double **pxy) { int i, j, n; double *xy; PyBufferProcs *buffer; Py_buffer view; if (PyPath_Check(data)) { /* This was another path object. */ PyPathObject *path = (PyPathObject*) data; xy = alloc_array(path->count); if (!xy) return -1; memcpy(xy, path->xy, 2 * path->count * sizeof(double)); *pxy = xy; return path->count; } buffer = Py_TYPE(data)->tp_as_buffer; if (buffer && buffer->bf_getbuffer && (*buffer->bf_getbuffer)(data, &view, PyBUF_SIMPLE) == 1) { /* Assume the buffer contains floats */ float* ptr; int n = view.len; PyBuffer_Release(&view); n /= 2 * sizeof(float); xy = alloc_array(n); if (!xy) return -1; for (i = 0; i < n+n; i++) xy[i] = ptr[i]; *pxy = xy; return n; } if (!PySequence_Check(data)) { PyErr_SetString(PyExc_TypeError, "argument must be sequence"); return -1; } j = 0; n = PyObject_Length(data); /* Just in case __len__ breaks (or doesn't exist) */ if (PyErr_Occurred()) return -1; /* Allocate for worst case */ xy = alloc_array(n); if (!xy) return -1; /* Copy table to path array */ if (PyList_Check(data)) { for (i = 0; i < n; i++) { double x, y; PyObject *op = PyList_GET_ITEM(data, i); if (PyFloat_Check(op)) xy[j++] = PyFloat_AS_DOUBLE(op); else if (PyLong_Check(op)) xy[j++] = (float) PyLong_AS_LONG(op); else if (PyNumber_Check(op)) xy[j++] = PyFloat_AsDouble(op); else if (PyArg_ParseTuple(op, "dd", &x, &y)) { xy[j++] = x; xy[j++] = y; } else { free(xy); return -1; } } } else if (PyTuple_Check(data)) { for (i = 0; i < n; i++) { double x, y; PyObject *op = PyTuple_GET_ITEM(data, i); if (PyFloat_Check(op)) xy[j++] = PyFloat_AS_DOUBLE(op); else if (PyLong_Check(op)) xy[j++] = (float) PyLong_AS_LONG(op); else if (PyNumber_Check(op)) xy[j++] = PyFloat_AsDouble(op); else if (PyArg_ParseTuple(op, "dd", &x, &y)) { xy[j++] = x; xy[j++] = y; } else { free(xy); return -1; } } } else { for (i = 0; i < n; i++) { double x, y; PyObject *op = PySequence_GetItem(data, i); if (!op) { /* treat IndexError as end of sequence */ if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_IndexError)) { PyErr_Clear(); break; } else { free(xy); return -1; } } if (PyFloat_Check(op)) xy[j++] = PyFloat_AS_DOUBLE(op); else if (PyLong_Check(op)) xy[j++] = (float) PyLong_AS_LONG(op); else if (PyNumber_Check(op)) xy[j++] = PyFloat_AsDouble(op); else if (PyArg_ParseTuple(op, "dd", &x, &y)) { xy[j++] = x; xy[j++] = y; } else { Py_DECREF(op); free(xy); return -1; } Py_DECREF(op); } } if (j & 1) { PyErr_SetString(PyExc_ValueError, "wrong number of coordinates"); free(xy); return -1; } *pxy = xy; return j/2; }
static PyObject* selNSGA2(PyObject *self, PyObject *args){ /* Args[0] : Individual list * Args[1] : Number of individuals wanted in output * Return : k selected individuals from input individual list */ PyObject *lListIndv = PyTuple_GetItem(args, 0); #ifdef PY3K unsigned long k = (unsigned long)PyLong_AS_LONG(PyTuple_GetItem(args, 1)); #else unsigned int k = (unsigned int)PyInt_AS_LONG(PyTuple_GetItem(args, 1)); #endif PyObject *lListSelect = PyList_New(0); unsigned int lLenListIndv = (unsigned int)PyList_Size(lListIndv); unsigned int lNbrObjectives = (unsigned int)PyTuple_Size(PyObject_GetAttrString(PyObject_GetAttrString(PyList_GetItem(lListIndv,0), "fitness"), "values")); if(k == 0) return lListSelect; // First : copy fitness values into an std::vector<std::vector<double> > // First vector index is used to identify individuals // Second vector index represents an objective std::vector<std::vector<double> > lPopFit(lLenListIndv, std::vector<double>(lNbrObjectives,0.)); for(unsigned int i = 0; i < lLenListIndv; i++){ for(unsigned int j = 0; j < lNbrObjectives; j++) lPopFit[i][j] = PyFloat_AS_DOUBLE(PyTuple_GetItem(PyObject_GetAttrString(PyObject_GetAttrString(PyList_GetItem(lListIndv,i), "fitness"), "wvalues"), j)); } unsigned int lParetoSorted = 0; unsigned int lFrontIndex = 0; std::vector<std::vector<unsigned int> > lParetoFront(1, std::vector<unsigned int>(0)); std::vector<unsigned int> lDominating(lLenListIndv, 0); std::vector<std::vector<unsigned int> > lDominatedInds(lLenListIndv, std::vector<unsigned int>(0)); // Rank first pareto front for(unsigned int i = 0; i < lLenListIndv; i++){ for(unsigned int j = i+1; j < lLenListIndv; j++){ if(isDominated(lPopFit[j], lPopFit[i])){ lDominating[j]++; lDominatedInds[i].push_back(j); } else if(isDominated(lPopFit[i], lPopFit[j])){ lDominating[i]++; lDominatedInds[j].push_back(i); } } if(lDominating[i] == 0){ lParetoFront[lFrontIndex].push_back(i); lParetoSorted++; } } // Rank other pareto fronts, until we reach the *k* limit while(lParetoSorted < k && lParetoSorted < lLenListIndv){ lFrontIndex++; lParetoFront.push_back(std::vector<unsigned int>(0)); for(unsigned int i = 0; i < lParetoFront[lFrontIndex-1].size(); i++){ unsigned int lIndiceP = lParetoFront[lFrontIndex-1][i]; for(unsigned int j = 0; j < lDominatedInds[lIndiceP].size(); j++){ unsigned int lIndiceD = lDominatedInds[lIndiceP][j]; if(--lDominating[lIndiceD] == 0){ lParetoFront[lFrontIndex].push_back(lIndiceD); lParetoSorted++; } } } } // Append individuals from pareto ranking until we reach the limit for(unsigned int i = 0; i < lParetoFront.size(); i++){ if(PyList_Size(lListSelect)+lParetoFront[i].size() <= k){ for(unsigned int j = 0; j < lParetoFront[i].size(); j++) PyList_Append(lListSelect, PyList_GetItem(lListIndv,lParetoFront[i][j])); } else{ break; } } // Crowding distance on the last front if(PyList_Size(lListSelect) == k) return lListSelect; FitComp lCmpIndvObj; std::vector<unsigned int> lLastParetoFront = lParetoFront.back(); std::vector<std::pair<double, unsigned int> > lDistances(0); std::vector<std::pair<std::vector<double>, unsigned int> > lCrowdingList(0); double lInfinity = std::numeric_limits<double>::infinity(); // Reserve sufficient memory for the subsequent push_back lDistances.reserve(lLastParetoFront.size()); lCrowdingList.reserve(lLastParetoFront.size()); for(unsigned int i = 0; i < lLastParetoFront.size(); i++){ // Push initial distance (0.0) and individual index in lPopFit and lListIndv for each individual lDistances.push_back(std::pair<double, unsigned int>(0., lLastParetoFront[i])); // Push fitness and individual index in lDistances for each individual lCrowdingList.push_back(std::pair<std::vector<double>, unsigned int>(lPopFit[lLastParetoFront[i]],i)); } for(unsigned int i = 0; i < lNbrObjectives; i++){ // For each objective // Set the current objective in the comparison class lCmpIndvObj.mCompIndex = i; // Sort (stable, in order to keep the same order for equal fitness values) stable_sort(lCrowdingList.begin(), lCrowdingList.end(), lCmpIndvObj); // Set an infinite distance to the extremums lDistances[lCrowdingList[0].second].first = lInfinity; lDistances[lCrowdingList.back().second].first = lInfinity; for(unsigned int j = 1; j < lCrowdingList.size()-1; j++){ if(lDistances[lCrowdingList[j].second].first < lInfinity) lDistances[lCrowdingList[j].second].first += lCrowdingList[j+1].first[i]-lCrowdingList[j-1].first[i]; } } // Final sorting (again, must be stable) stable_sort(lDistances.begin(), lDistances.end(), crowdDistComp); // Pick the last individuals (with the higher crowding distance) first for(unsigned int i = lDistances.size()-1; i >= 0; i--){ if(PyList_Size(lListSelect) >= k) break; // While the size of the return list is lesser than *k*, append the next individual PyList_Append(lListSelect, PyList_GetItem(lListIndv,lDistances[i].second)); } return lListSelect; }
PyObject *add_pyevrepr(track_ctx_t *trackctx, PyObject *pyevrepr) { uint_t type, tick; Py_ssize_t repr_sz; midicev_t mcev; PyObject *obj = NULL; ev_iterator_t evit; evit_init(&evit, &(trackctx->track->tickev_list)); if (!PyTuple_Check(pyevrepr)) { output_error("Event representation is not a tuple"); return NULL; } repr_sz = PyTuple_GET_SIZE(pyevrepr); if (repr_sz != 5) { output_error("Unsupported event representation (list size %d mismatch)", repr_sz); return NULL; } obj = PyTuple_GetItem(pyevrepr, 2); type = PyLong_AS_LONG(obj); switch (type) { case NOTEON: case NOTEOFF: obj = PyTuple_GetItem(pyevrepr, 1); mcev.chan = PyLong_AS_LONG(obj); mcev.type = type; obj = PyTuple_GetItem(pyevrepr, 3); mcev.event.note.num = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 4); mcev.event.note.val = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 0); tick = PyLong_AS_LONG(obj); evit_add_midicev(&evit, tick, &mcev); obj = build_evwr_from_evit(&evit, trackctx); break; case CONTROLCHANGE: obj = PyTuple_GetItem(pyevrepr, 1); mcev.chan = PyLong_AS_LONG(obj); mcev.type = type; obj = PyTuple_GetItem(pyevrepr, 3); mcev.event.ctrl.num = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 4); mcev.event.ctrl.val = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 0); tick = PyLong_AS_LONG(obj); evit_add_midicev(&evit, tick, &mcev); obj = build_evwr_from_evit(&evit, trackctx); break; case PITCHWHEELCHANGE: obj = PyTuple_GetItem(pyevrepr, 1); mcev.chan = PyLong_AS_LONG(obj); mcev.type = type; obj = PyTuple_GetItem(pyevrepr, 3); mcev.event.pitchbend.Lval = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 4); mcev.event.pitchbend.Hval = PyLong_AS_LONG(obj); obj = PyTuple_GetItem(pyevrepr, 0); tick = PyLong_AS_LONG(obj); evit_add_midicev(&evit, tick, &mcev); obj = build_evwr_from_evit(&evit, trackctx); break; default: output_error("Unsupported event type"); } return obj; }
static PyObject *bip_sum(term_t t) { PyObject *seq; PyObject *result = NULL; PyObject *temp, *item, *iter; if (!PL_get_arg(1, t, t)) return NULL; seq = term_to_python(t, true); iter = PyObject_GetIter(seq); if (iter == NULL) return NULL; if (result == NULL) { #if PY_MAJOR_VERSION < 3 result = PyInt_FromLong(0); #else result = PyLong_FromLong(0); #endif if (result == NULL) { Py_DECREF(iter); return NULL; } } else { #if PY_MAJOR_VERSION < 3 /* reject string values for 'start' parameter */ if (PyObject_TypeCheck(result, &PyBaseString_Type)) { PyErr_SetString(PyExc_TypeError, "sum() can't sum strings [use ''.join(seq) instead]"); Py_DECREF(iter); return NULL; } Py_INCREF(result); #endif } #ifndef SLOW_SUM /* Fast addition by keeping temporary sums in C instead of new Python objects. Assumes all inputs are the same type. If the assumption fails, default to the more general routine. */ #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(result)) { long i_result = PyInt_AS_LONG(result); #else if (PyLong_CheckExact(result)) { long i_result = PyLong_AS_LONG(result); #endif Py_DECREF(result); result = NULL; while (result == NULL) { item = PyIter_Next(iter); if (item == NULL) { Py_DECREF(iter); if (PyErr_Occurred()) return NULL; #if PY_MAJOR_VERSION < 3 return PyInt_FromLong(i_result); #else return PyLong_FromLong(i_result); #endif } #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(item)) { long b = PyInt_AS_LONG(item); #else if (PyLong_CheckExact(item)) { long b = PyLong_AS_LONG(item); #endif long x = i_result + b; if ((x ^ i_result) >= 0 || (x ^ b) >= 0) { i_result = x; Py_DECREF(item); continue; } } /* Either overflowed or is not an int. Restore real objects and process normally */ #if PY_MAJOR_VERSION < 3 result = PyInt_FromLong(i_result); #else result = PyLong_FromLong(i_result); #endif temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); result = temp; if (result == NULL) { Py_DECREF(iter); return NULL; } } } if (PyFloat_CheckExact(result)) { double f_result = PyFloat_AS_DOUBLE(result); Py_DECREF(result); result = NULL; while (result == NULL) { item = PyIter_Next(iter); if (item == NULL) { Py_DECREF(iter); if (PyErr_Occurred()) return NULL; return PyFloat_FromDouble(f_result); } if (PyFloat_CheckExact(item)) { PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) f_result += PyFloat_AS_DOUBLE(item); PyFPE_END_PROTECT(f_result) Py_DECREF(item); continue; } #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(item)) { PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) f_result += (double)PyInt_AS_LONG(item); PyFPE_END_PROTECT(f_result) Py_DECREF(item); continue; } #else if (PyLong_CheckExact(item)) { PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) f_result += PyLong_AsDouble(item); PyFPE_END_PROTECT(f_result) Py_DECREF(item); continue; } #endif result = PyFloat_FromDouble(f_result); temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); result = temp; if (result == NULL) { Py_DECREF(iter); return NULL; } } #endif } for (;;) { item = PyIter_Next(iter); if (item == NULL) { /* error, or end-of-sequence */ if (PyErr_Occurred()) { Py_DECREF(result); result = NULL; } break; } /* It's tempting to use PyNumber_InPlaceAdd instead of PyNumber_Add here, to avoid quadratic running time when doing 'sum(list_of_lists, [])'. However, this would produce a change in behaviour: a snippet like empty = [] sum([[x] for x in range(10)], empty) would change the value of empty. */ temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); result = temp; if (result == NULL) break; } Py_DECREF(iter); return result; } //@} static long get_int(term_t arg, bool eval) { long low; if (!PL_get_long(arg, &low)) { PyObject *low = term_to_python(arg, eval); if (PyLong_Check(low)) { return PyLong_AsLong(low); #if PY_MAJOR_VERSION < 3 } else if (PyInt_Check(low)) { return PyInt_AsLong(low); #endif } else { return 0; } } return low; } /* Return number of items in range/xrange (lo, hi, step). step > 0 * required. Return a value < 0 if & only if the true value is too * large to fit in a signed long. */ static long get_len_of_range(long lo, long hi, long step) { /* ------------------------------------------------------------- If lo >= hi, the range is empty. Else if n values are in the range, the last one is lo + (n-1)*step, which must be <= hi-1. Rearranging, n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so the RHS is non-negative and so truncation is the same as the floor. Letting M be the largest positive long, the worst case for the RHS numerator is hi=M, lo=-M-1, and then hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough precision to compute the RHS exactly. ---------------------------------------------------------------*/ long n = 0; if (lo < hi) { unsigned long uhi = (unsigned long)hi; unsigned long ulo = (unsigned long)lo; unsigned long diff = uhi - ulo - 1; n = (long)(diff / (unsigned long)step + 1); } return n; }
static PyObject *PySSL_SSLread(PySSLObject *self, PyObject *args) { PyObject *dest = NULL; Py_buffer buf; int buf_passed = 0; int count = -1; char *mem; /* XXX this should use Py_ssize_t */ int len = 1024; int sockstate; int err; int nonblocking; PySocketSockObject *sock = (PySocketSockObject *) PyWeakref_GetObject(self->Socket); if (((PyObject*)sock) == Py_None) { _setSSLError("Underlying socket connection gone", PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__); return NULL; } if (!PyArg_ParseTuple(args, "|Oi:read", &dest, &count)) return NULL; if ((dest == NULL) || (dest == Py_None)) { if (!(dest = PyByteArray_FromStringAndSize((char *) 0, len))) return NULL; mem = PyByteArray_AS_STRING(dest); } else if (PyLong_Check(dest)) { len = PyLong_AS_LONG(dest); if (!(dest = PyByteArray_FromStringAndSize((char *) 0, len))) return NULL; mem = PyByteArray_AS_STRING(dest); } else { if (PyObject_GetBuffer(dest, &buf, PyBUF_CONTIG) < 0) return NULL; mem = buf.buf; len = buf.len; if ((count > 0) && (count <= len)) len = count; buf_passed = 1; } /* just in case the blocking state of the socket has been changed */ nonblocking = (sock->sock_timeout >= 0.0); BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking); BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking); /* first check if there are bytes ready to be read */ PySSL_BEGIN_ALLOW_THREADS count = SSL_pending(self->ssl); PySSL_END_ALLOW_THREADS if (!count) { sockstate = check_socket_and_wait_for_timeout(sock, 0); if (sockstate == SOCKET_HAS_TIMED_OUT) { PyErr_SetString(PySSLErrorObject, "The read operation timed out"); goto error; } else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) { PyErr_SetString(PySSLErrorObject, "Underlying socket too large for select()."); goto error; } else if (sockstate == SOCKET_HAS_BEEN_CLOSED) { count = 0; goto done; } } do { err = 0; PySSL_BEGIN_ALLOW_THREADS count = SSL_read(self->ssl, mem, len); err = SSL_get_error(self->ssl, count); PySSL_END_ALLOW_THREADS if (PyErr_CheckSignals()) goto error; if (err == SSL_ERROR_WANT_READ) { sockstate = check_socket_and_wait_for_timeout(sock, 0); } else if (err == SSL_ERROR_WANT_WRITE) { sockstate = check_socket_and_wait_for_timeout(sock, 1); } else if ((err == SSL_ERROR_ZERO_RETURN) && (SSL_get_shutdown(self->ssl) == SSL_RECEIVED_SHUTDOWN)) { count = 0; goto done; } else { sockstate = SOCKET_OPERATION_OK; } if (sockstate == SOCKET_HAS_TIMED_OUT) { PyErr_SetString(PySSLErrorObject, "The read operation timed out"); goto error; } else if (sockstate == SOCKET_IS_NONBLOCKING) { break; } } while (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE); if (count <= 0) { PySSL_SetError(self, count, __FILE__, __LINE__); goto error; } done: if (!buf_passed) { PyObject *res = PyBytes_FromStringAndSize(mem, count); Py_DECREF(dest); return res; } else { PyBuffer_Release(&buf); return PyLong_FromLong(count); } error: if (!buf_passed) { Py_DECREF(dest); } else { PyBuffer_Release(&buf); } return NULL; }
// Convert a Python object to a QJSValue. int qpyqml_convertTo_QJSValue(PyObject *py, PyObject *transferObj, QJSValue **cpp, int *isErr) { if (PyObject_TypeCheck(py, sipTypeAsPyTypeObject(sipType_QJSValue_SpecialValue))) { *cpp = new QJSValue((QJSValue::SpecialValue)SIPLong_AsLong(py)); return sipGetState(transferObj); } if (PyBool_Check(py)) { *cpp = new QJSValue(py == Py_True); return sipGetState(transferObj); } #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(py)) { *cpp = new QJSValue((int)PyLong_AS_LONG(py)); return sipGetState(transferObj); } #else if (PyInt_Check(py)) { *cpp = new QJSValue((int)PyInt_AS_LONG(py)); return sipGetState(transferObj); } #endif if (PyFloat_Check(py)) { *cpp = new QJSValue((double)PyFloat_AS_DOUBLE(py)); return sipGetState(transferObj); } if (sipCanConvertToType(py, sipType_QString, 0)) { int state; QString *qs = reinterpret_cast<QString *>(sipConvertToType(py, sipType_QString, 0, 0, &state, isErr)); if (*isErr) { sipReleaseType(qs, sipType_QString, state); return 0; } *cpp = new QJSValue(*qs); sipReleaseType(qs, sipType_QString, state); return sipGetState(transferObj); } *cpp = reinterpret_cast<QJSValue *>(sipConvertToType(py, sipType_QJSValue, transferObj, SIP_NO_CONVERTORS, 0, isErr)); return 0; }
static PyObject * SpiDev_xfer(SpiDevObject *self, PyObject *args) { uint16_t ii, len; int status; uint16_t delay_usecs = 0; uint32_t speed_hz = 0; uint8_t bits_per_word = 0; PyObject *list; #ifdef SPIDEV_SINGLE struct spi_ioc_transfer *xferptr; memset(&xferptr, 0, sizeof(xferptr)); #else struct spi_ioc_transfer xfer; memset(&xfer, 0, sizeof(xfer)); #endif uint8_t *txbuf, *rxbuf; if (!PyArg_ParseTuple(args, "O|IHB:xfer", &list, &speed_hz, &delay_usecs, &bits_per_word)) return NULL; if (!PyList_Check(list)) { PyErr_SetString(PyExc_TypeError, wrmsg); return NULL; } if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) { PyErr_SetString(PyExc_OverflowError, wrmsg); return NULL; } txbuf = malloc(sizeof(__u8) * len); rxbuf = malloc(sizeof(__u8) * len); #ifdef SPIDEV_SINGLE xferptr = (struct spi_ioc_transfer*) malloc(sizeof(struct spi_ioc_transfer) * len); for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); if (!PyLong_Check(val)) { PyErr_SetString(PyExc_TypeError, wrmsg); free(xferptr); free(txbuf); free(rxbuf); return NULL; } txbuf[ii] = (__u8)PyLong_AS_LONG(val); xferptr[ii].tx_buf = (unsigned long)&txbuf[ii]; xferptr[ii].rx_buf = (unsigned long)&rxbuf[ii]; xferptr[ii].len = 1; xferptr[ii].delay_usecs = delay; xferptr[ii].speed_hz = speed_hz ? speed_hz : self->max_speed_hz; xferptr[ii].bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word; #ifdef SPI_IOC_WR_MODE32 xferptr[ii].tx_nbits = 0; #endif #ifdef SPI_IOC_RD_MODE32 xferptr[ii].rx_nbits = 0; #endif } status = ioctl(self->fd, SPI_IOC_MESSAGE(len), xferptr); if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); free(xferptr); free(txbuf); free(rxbuf); return NULL; } #else for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); if (!PyLong_Check(val)) { PyErr_SetString(PyExc_TypeError, wrmsg); free(txbuf); free(rxbuf); return NULL; } txbuf[ii] = (__u8)PyLong_AS_LONG(val); } xfer.tx_buf = (unsigned long)txbuf; xfer.rx_buf = (unsigned long)rxbuf; xfer.len = len; xfer.delay_usecs = delay_usecs; xfer.speed_hz = speed_hz ? speed_hz : self->max_speed_hz; xfer.bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word; #ifdef SPI_IOC_WR_MODE32 xfer.tx_nbits = 0; #endif #ifdef SPI_IOC_RD_MODE32 xfer.rx_nbits = 0; #endif status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer); if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); free(txbuf); free(rxbuf); return NULL; } #endif list = PyList_New(len); for (ii = 0; ii < len; ii++) { PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]); PyList_SET_ITEM(list, ii, val); } // WA: // in CS_HIGH mode CS isn't pulled to low after transfer, but after read // reading 0 bytes doesnt matter but brings cs down // tomdean: // Stop generating an extra CS except in mode CS_HOGH if (self->mode & SPI_CS_HIGH) status = read(self->fd, &rxbuf[0], 0); free(txbuf); free(rxbuf); return list; }
static PyObject *integer(PyObject *self, PyObject *args, PyObject *kwrds) { matrix *c, *h, *b=NULL, *x=NULL; PyObject *G, *A=NULL, *IntSet=NULL, *BinSet = NULL; PyObject *t=NULL; pyiocp *iocpParm = NULL;; glp_iocp *options = NULL; glp_prob *lp; int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL; double *a=NULL, val; char *kwlist[] = {"c", "G", "h", "A", "b", "I", "B","iocp", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOOOO!", kwlist, &c, &G, &h, &A, &b, &IntSet, &BinSet,iocp_t,&iocpParm)) return NULL; if(!iocpParm) { iocpParm = (pyiocp*)malloc(sizeof(*iocpParm)); glp_init_iocp(&(iocpParm->obj)); } if(iocpParm) { Py_INCREF(iocpParm); options = &iocpParm->obj; options->presolve = 1; } if ((Matrix_Check(G) && MAT_ID(G) != DOUBLE) || (SpMatrix_Check(G) && SP_ID(G) != DOUBLE) || (!Matrix_Check(G) && !SpMatrix_Check(G))){ PyErr_SetString(PyExc_TypeError, "G must be a 'd' matrix"); return NULL; } if ((m = Matrix_Check(G) ? MAT_NROWS(G) : SP_NROWS(G)) <= 0) err_p_int("m"); if ((n = Matrix_Check(G) ? MAT_NCOLS(G) : SP_NCOLS(G)) <= 0) err_p_int("n"); if (!Matrix_Check(h) || h->id != DOUBLE) err_dbl_mtrx("h"); if (h->nrows != m || h->ncols != 1){ PyErr_SetString(PyExc_ValueError, "incompatible dimensions"); return NULL; } if (A){ if ((Matrix_Check(A) && MAT_ID(A) != DOUBLE) || (SpMatrix_Check(A) && SP_ID(A) != DOUBLE) || (!Matrix_Check(A) && !SpMatrix_Check(A))){ PyErr_SetString(PyExc_ValueError, "A must be a dense " "'d' matrix or a general sparse matrix"); return NULL; } if ((p = Matrix_Check(A) ? MAT_NROWS(A) : SP_NROWS(A)) < 0) err_p_int("p"); if ((Matrix_Check(A) ? MAT_NCOLS(A) : SP_NCOLS(A)) != n){ PyErr_SetString(PyExc_ValueError, "incompatible " "dimensions"); return NULL; } } else p = 0; if (b && (!Matrix_Check(b) || b->id != DOUBLE)) err_dbl_mtrx("b"); if ((b && (b->nrows != p || b->ncols != 1)) || (!b && p !=0 )){ PyErr_SetString(PyExc_ValueError, "incompatible dimensions"); return NULL; } if ((IntSet) && (!PyAnySet_Check(IntSet))) PY_ERR_TYPE("invalid integer index set"); if ((BinSet) && (!PyAnySet_Check(BinSet))) PY_ERR_TYPE("invalid binary index set"); lp = glp_create_prob(); glp_add_rows(lp, m+p); glp_add_cols(lp, n); for (i=0; i<n; i++){ glp_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]); glp_set_col_bnds(lp, i+1, GLP_FR, 0.0, 0.0); } for (i=0; i<m; i++) glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]); for (i=0; i<p; i++) glp_set_row_bnds(lp, i+m+1, GLP_FX, MAT_BUFD(b)[i], MAT_BUFD(b)[i]); nnzmax = (SpMatrix_Check(G) ? SP_NNZ(G) : m*n ) + ((A && SpMatrix_Check(A)) ? SP_NNZ(A) : p*n); a = (double *) calloc(nnzmax+1, sizeof(double)); rn = (int *) calloc(nnzmax+1, sizeof(int)); cn = (int *) calloc(nnzmax+1, sizeof(int)); if (!a || !rn || !cn){ free(a); free(rn); free(cn); glp_delete_prob(lp); return PyErr_NoMemory(); } nnz = 0; if (SpMatrix_Check(G)) { for (j=0; j<n; j++) for (k=SP_COL(G)[j]; k<SP_COL(G)[j+1]; k++) if ((val = SP_VALD(G)[k]) != 0.0){ a[1+nnz] = val; rn[1+nnz] = SP_ROW(G)[k]+1; cn[1+nnz] = j+1; nnz++; } } else for (j=0; j<n; j++) for (i=0; i<m; i++) if ((val = MAT_BUFD(G)[i+j*m]) != 0.0){ a[1+nnz] = val; rn[1+nnz] = i+1; cn[1+nnz] = j+1; nnz++; } if (A && SpMatrix_Check(A)){ for (j=0; j<n; j++) for (k=SP_COL(A)[j]; k<SP_COL(A)[j+1]; k++) if ((val = SP_VALD(A)[k]) != 0.0){ a[1+nnz] = val; rn[1+nnz] = m+SP_ROW(A)[k]+1; cn[1+nnz] = j+1; nnz++; } } else for (j=0; j<n; j++) for (i=0; i<p; i++) if ((val = MAT_BUFD(A)[i+j*p]) != 0.0){ a[1+nnz] = val; rn[1+nnz] = m+i+1; cn[1+nnz] = j+1; nnz++; } glp_load_matrix(lp, nnz, rn, cn, a); free(rn); free(cn); free(a); if (!(t = PyTuple_New(2))) { glp_delete_prob(lp); return PyErr_NoMemory(); } if (IntSet) { PyObject *iter = PySequence_Fast(IntSet, "Critical error: not sequence"); for (i=0; i<PySet_GET_SIZE(IntSet); i++) { PyObject *tmp = PySequence_Fast_GET_ITEM(iter, i); #if PY_MAJOR_VERSION >= 3 if (!PyLong_Check(tmp)) { #else if (!PyInt_Check(tmp)) { #endif glp_delete_prob(lp); Py_DECREF(iter); PY_ERR_TYPE("non-integer element in I"); } #if PY_MAJOR_VERSION >= 3 int k = PyLong_AS_LONG(tmp); #else int k = PyInt_AS_LONG(tmp); #endif if ((k < 0) || (k >= n)) { glp_delete_prob(lp); Py_DECREF(iter); PY_ERR(PyExc_IndexError, "index element out of range in I"); } glp_set_col_kind(lp, k+1, GLP_IV); } Py_DECREF(iter); } if (BinSet) { PyObject *iter = PySequence_Fast(BinSet, "Critical error: not sequence"); for (i=0; i<PySet_GET_SIZE(BinSet); i++) { PyObject *tmp = PySequence_Fast_GET_ITEM(iter, i); #if PY_MAJOR_VERSION >= 3 if (!PyLong_Check(tmp)) { #else if (!PyInt_Check(tmp)) { #endif glp_delete_prob(lp); Py_DECREF(iter); PY_ERR_TYPE("non-binary element in I"); } #if PY_MAJOR_VERSION >= 3 int k = PyLong_AS_LONG(tmp); #else int k = PyInt_AS_LONG(tmp); #endif if ((k < 0) || (k >= n)) { glp_delete_prob(lp); Py_DECREF(iter); PY_ERR(PyExc_IndexError, "index element out of range in B"); } glp_set_col_kind(lp, k+1, GLP_BV); } Py_DECREF(iter); } switch (glp_intopt(lp,options)){ case 0: x = (matrix *) Matrix_New(n,1,DOUBLE); if (!x) { Py_XDECREF(iocpParm); Py_XDECREF(t); glp_delete_prob(lp); return PyErr_NoMemory(); } set_output_string(t,"optimal"); set_output_string(t,"optimal"); for (i=0; i<n; i++) MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1); PyTuple_SET_ITEM(t, 1, (PyObject *) x); Py_XDECREF(iocpParm); glp_delete_prob(lp); return (PyObject *) t; case GLP_ETMLIM: x = (matrix *) Matrix_New(n,1,DOUBLE); if (!x) { Py_XDECREF(t); Py_XDECREF(iocpParm); glp_delete_prob(lp); return PyErr_NoMemory(); } set_output_string(t,"time limit exceeded"); for (i=0; i<n; i++) MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1); PyTuple_SET_ITEM(t, 1, (PyObject *) x); Py_XDECREF(iocpParm); glp_delete_prob(lp); return (PyObject *) t; case GLP_EBOUND: set_output_string(t,"incorrect bounds"); break; case GLP_EFAIL: set_output_string(t,"invalid MIP formulation"); break; case GLP_ENOPFS: set_output_string(t,"primal infeasible"); break; case GLP_ENODFS: set_output_string(t,"dual infeasible"); break; case GLP_EMIPGAP: set_output_string(t,"Relative mip gap tolerance reached"); break; /*case LPX_E_ITLIM: set_output_string(t,"maxiters exceeded"); break;*/ /*case LPX_E_SING: set_output_string(t,"singular or ill-conditioned basis"); break;*/ default: set_output_string(t,"unknown"); } Py_XDECREF(iocpParm); glp_delete_prob(lp); PyTuple_SET_ITEM(t, 1, Py_BuildValue("")); return (PyObject *) t; } static PyMethodDef glpk_functions[] = { {"lp", (PyCFunction) simplex, METH_VARARGS|METH_KEYWORDS, doc_simplex}, {"ilp", (PyCFunction) integer, METH_VARARGS|METH_KEYWORDS, doc_integer}, {NULL} /* Sentinel */ }; #if PY_MAJOR_VERSION >= 3 static PyModuleDef glpk_module_def = { PyModuleDef_HEAD_INIT, "glpk", glpk__doc__, -1, glpk_functions, NULL, NULL, NULL, NULL }; void addglpkConstants (void) { PyModule_AddIntMacro(glpk_module, GLP_ON); PyModule_AddIntMacro(glpk_module,GLP_OFF); /* reason codes: */ PyModule_AddIntMacro(glpk_module,GLP_IROWGEN); PyModule_AddIntMacro(glpk_module,GLP_IBINGO); PyModule_AddIntMacro(glpk_module,GLP_IHEUR); PyModule_AddIntMacro(glpk_module,GLP_ICUTGEN); PyModule_AddIntMacro(glpk_module,GLP_IBRANCH); PyModule_AddIntMacro(glpk_module,GLP_ISELECT); PyModule_AddIntMacro(glpk_module,GLP_IPREPRO); /* branch selection indicator: */ PyModule_AddIntMacro(glpk_module,GLP_NO_BRNCH); PyModule_AddIntMacro(glpk_module,GLP_DN_BRNCH); PyModule_AddIntMacro(glpk_module,GLP_UP_BRNCH); /* return codes: */ PyModule_AddIntMacro(glpk_module,GLP_EBADB); PyModule_AddIntMacro(glpk_module,GLP_ESING); PyModule_AddIntMacro(glpk_module,GLP_ECOND); PyModule_AddIntMacro(glpk_module,GLP_EBOUND); PyModule_AddIntMacro(glpk_module,GLP_EFAIL); PyModule_AddIntMacro(glpk_module,GLP_EOBJLL); PyModule_AddIntMacro(glpk_module,GLP_EOBJUL); PyModule_AddIntMacro(glpk_module,GLP_EITLIM); PyModule_AddIntMacro(glpk_module,GLP_ETMLIM); PyModule_AddIntMacro(glpk_module,GLP_ENOPFS); PyModule_AddIntMacro(glpk_module,GLP_ENODFS); PyModule_AddIntMacro(glpk_module,GLP_EROOT); PyModule_AddIntMacro(glpk_module,GLP_ESTOP); PyModule_AddIntMacro(glpk_module,GLP_EMIPGAP); PyModule_AddIntMacro(glpk_module,GLP_ENOFEAS); PyModule_AddIntMacro(glpk_module,GLP_ENOCVG); PyModule_AddIntMacro(glpk_module,GLP_EINSTAB); PyModule_AddIntMacro(glpk_module,GLP_EDATA); PyModule_AddIntMacro(glpk_module,GLP_ERANGE); /* condition indicator: */ PyModule_AddIntMacro(glpk_module,GLP_KKT_PE); PyModule_AddIntMacro(glpk_module,GLP_KKT_PB); PyModule_AddIntMacro(glpk_module,GLP_KKT_DE); PyModule_AddIntMacro(glpk_module,GLP_KKT_DB); PyModule_AddIntMacro(glpk_module,GLP_KKT_CS); /* MPS file format: */ PyModule_AddIntMacro(glpk_module,GLP_MPS_DECK); PyModule_AddIntMacro(glpk_module,GLP_MPS_FILE); /* simplex method control parameters */ /* message level: */ PyModule_AddIntMacro(glpk_module,GLP_MSG_OFF); PyModule_AddIntMacro(glpk_module,GLP_MSG_ERR); PyModule_AddIntMacro(glpk_module,GLP_MSG_ON); PyModule_AddIntMacro(glpk_module,GLP_MSG_ALL); PyModule_AddIntMacro(glpk_module,GLP_MSG_DBG); /* simplex method option: */ PyModule_AddIntMacro(glpk_module,GLP_PRIMAL); PyModule_AddIntMacro(glpk_module,GLP_DUALP); PyModule_AddIntMacro(glpk_module,GLP_DUAL); /* pricing technique: */ PyModule_AddIntMacro(glpk_module,GLP_PT_STD); PyModule_AddIntMacro(glpk_module,GLP_PT_PSE); /* ratio test technique: */ PyModule_AddIntMacro(glpk_module,GLP_RT_STD); PyModule_AddIntMacro(glpk_module,GLP_RT_HAR); /* interior-point solver control parameters */ /* ordering algorithm: */ PyModule_AddIntMacro(glpk_module,GLP_ORD_NONE); PyModule_AddIntMacro(glpk_module,GLP_ORD_QMD); PyModule_AddIntMacro(glpk_module,GLP_ORD_AMD); PyModule_AddIntMacro(glpk_module,GLP_ORD_SYMAMD); } PyMODINIT_FUNC PyInit_glpk(void) { if (!(glpk_module = PyModule_Create(&glpk_module_def))) return NULL; if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL; /* Adding macros */ addglpkConstants(); /* Adding option lists as objects */ Py_INCREF(&smcp_t); PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t); Py_INCREF(&iocp_t); PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t); if (import_cvxopt() < 0) return NULL; return glpk_module; } #else PyMODINIT_FUNC initglpk(void) { glpk_module = Py_InitModule3("cvxopt.glpk", glpk_functions, glpk__doc__); if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL; addglpkConstants(); Py_INCREF(&smcp_t); PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t); Py_INCREF(&iocp_t); PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t); if (import_cvxopt() < 0) return; }
static PyObject * SpiDev_xfer2(SpiDevObject *self, PyObject *args) { static char *msg = "Argument must be a list of at least one, " "but not more than 4096 integers"; int status; uint16_t delay_usecs = 0; uint32_t speed_hz = 0; uint8_t bits_per_word = 0; uint16_t ii, len; PyObject *list; struct spi_ioc_transfer xfer; memset(&xfer, 0, sizeof(xfer)); uint8_t *txbuf, *rxbuf; if (!PyArg_ParseTuple(args, "O|IHB:xfer2", &list, &speed_hz, &delay_usecs, &bits_per_word)) return NULL; if (!PyList_Check(list)) { PyErr_SetString(PyExc_TypeError, wrmsg); return NULL; } if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) { PyErr_SetString(PyExc_OverflowError, wrmsg); return NULL; } txbuf = malloc(sizeof(__u8) * len); rxbuf = malloc(sizeof(__u8) * len); for (ii = 0; ii < len; ii++) { PyObject *val = PyList_GET_ITEM(list, ii); if (!PyLong_Check(val)) { PyErr_SetString(PyExc_TypeError, msg); free(txbuf); free(rxbuf); return NULL; } txbuf[ii] = (__u8)PyLong_AS_LONG(val); } xfer.tx_buf = (unsigned long)txbuf; xfer.rx_buf = (unsigned long)rxbuf; xfer.len = len; xfer.delay_usecs = delay_usecs; xfer.speed_hz = speed_hz ? speed_hz : self->max_speed_hz; xfer.bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word; status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer); if (status < 0) { PyErr_SetFromErrno(PyExc_IOError); free(txbuf); free(rxbuf); return NULL; } list = PyList_New(len); for (ii = 0; ii < len; ii++) { PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]); PyList_SET_ITEM(list, ii, val); } // WA: // in CS_HIGH mode CS isnt pulled to low after transfer // reading 0 bytes doesn't really matter but brings CS down // tomdean: // Stop generating an extra CS except in mode CS_HOGH if (self->mode & SPI_CS_HIGH) status = read(self->fd, &rxbuf[0], 0); free(txbuf); free(rxbuf); return list; }