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;
}
