static PyObject *mpy_Matrix_inplace_mul(PyObject *M, PyObject *N)
{
PyObject *tmp_arg_as_py_double;
if (PyObject_TypeCheck(M, &mpy_MatrixType)) {
if (PyNumber_Check(N)) {
tmp_arg_as_py_double = PyNumber_Float(N);
if (tmp_arg_as_py_double != NULL) {
double N_as_double = PyFloat_AsDouble(tmp_arg_as_py_double);
((mpy_Matrix *)M)->M *= N_as_double;
Py_INCREF(M);
return M;
}
}
}
else if (PyNumber_Check(M)) {
if (PyObject_TypeCheck(N, &mpy_MatrixType)) {
tmp_arg_as_py_double = PyNumber_Float(M);
if (tmp_arg_as_py_double != NULL) {
double M_as_double = PyFloat_AsDouble(tmp_arg_as_py_double);
((mpy_Matrix *)N)->M *= M_as_double;
Py_INCREF(N);
return N;
}
}
}
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *mpy_Matrix_mul(PyObject *M, PyObject *N)
{
PyObject *tmp_arg_as_py_double;
mpy_Matrix *result;
if (PyObject_TypeCheck(M, &mpy_MatrixType)) {
if (PyNumber_Check(N)) {
tmp_arg_as_py_double = PyNumber_Float(N);
if (tmp_arg_as_py_double != NULL) {
double N_as_double = PyFloat_AsDouble(tmp_arg_as_py_double);
result = mpy_Matrix_NEW();
result->M = (((mpy_Matrix *)M)->M)*N_as_double;
return (PyObject *)result;
}
}
}
else if (PyNumber_Check(M)) {
if (PyObject_TypeCheck(N, &mpy_MatrixType)) {
tmp_arg_as_py_double = PyNumber_Float(M);
if (tmp_arg_as_py_double != NULL) {
double M_as_double = PyFloat_AsDouble(tmp_arg_as_py_double);
result = mpy_Matrix_NEW();
result->M = (((mpy_Matrix *)N)->M)*M_as_double;
return (PyObject *)result;
}
}
}
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *Polygon_addContour(Polygon *self, PyObject *args) {
#ifdef WITH_NUMERIC
PyObject *a=NULL;
gpc_vertex_list *vl;
int hole = 0;
if (! PyArg_ParseTuple(args, "O|i", &a, &hole))
return Polygon_Raise(ERR_ARG);
if ((a = PyArray_ContiguousFromObject(a, PyArray_DOUBLE, 2, 2)) == NULL)
return Polygon_Raise(ERR_ARG);
if (((PyArrayObject *)a)->nd != 2) return Polygon_Raise(ERR_ARG);
if (((PyArrayObject *)a)->dimensions[1] != 2) return Polygon_Raise(ERR_ARG);
vl = PyMem_New(gpc_vertex_list, 1);
vl->num_vertices = ((PyArrayObject *)a)->dimensions[0];
vl->vertex = PyMem_New(gpc_vertex, vl->num_vertices);
memcpy((vl->vertex), (((PyArrayObject *)a)->data), 2*vl->num_vertices*sizeof(double));
Py_DECREF(a);
#else
PyObject *list=NULL, *flist, *point=NULL, *X, *Y;
gpc_vertex_list *vl;
gpc_vertex *v;
int i, imax, hole = 0;
if (! PyArg_ParseTuple(args, "O|i", &list, &hole))
return Polygon_Raise(ERR_ARG);
if (! PySequence_Check(list))
return Polygon_Raise(ERR_ARG);
flist = PySequence_Fast(list, "this is not a sequence");
if ((! flist) || ((imax = PySequence_Length(flist)) <= 2))
return Polygon_Raise(ERR_INV);
vl = PyMem_New(gpc_vertex_list, 1);
vl->num_vertices = imax;
vl->vertex = v = PyMem_New(gpc_vertex, imax);
for (i=0; i<imax; i++) {
point = PySequence_Fast(PySequence_Fast_GET_ITEM(flist, i), "this is not a point");
if ((!point) || (PySequence_Length(point) != 2))
return Polygon_Raise(ERR_INV);
v->x = PyFloat_AsDouble(X = PyNumber_Float(PySequence_Fast_GET_ITEM(point, 0)));
v->y = PyFloat_AsDouble(Y = PyNumber_Float(PySequence_Fast_GET_ITEM(point, 1)));
v++;
Py_DECREF(X);
Py_DECREF(Y);
Py_DECREF(point);
}
Py_DECREF(flist);
#endif /* WITH_NUMERIC */
gpc_add_contour(self->p, vl, hole);
self->bbValid = 0;
PyMem_Free(vl->vertex);
PyMem_Free(vl);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
LFO_setFreq(LFO *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->freq);
if (isNumber == 1) {
self->freq = PyNumber_Float(tmp);
self->modebuffer[2] = 0;
}
else {
self->freq = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->freq, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->freq_stream);
self->freq_stream = (Stream *)streamtmp;
self->modebuffer[2] = 1;
}
(*self->mode_func_ptr)(self);
Py_INCREF(Py_None);
return Py_None;
}
PyObject * tupleToDoubleArray(PyObject *tuple_obj, double *arr, unsigned n, int demandExactLen) {
PyObject *item, *f_item;
unsigned pytuple_len = (unsigned) PyTuple_Size(tuple_obj);
unsigned i;
if (pytuple_len != n && ((demandExactLen != 0) || (pytuple_len < n))) {
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return 0L;
}
for (i = 0; i < n; ++i) {
item = PyTuple_GetItem(tuple_obj, i);
if (item == 0L) {
return 0L;
}
Py_INCREF(item);
f_item = PyNumber_Float(item);
if (f_item == 0L) {
Py_DECREF(item);
return 0L;
}
arr[i] = PyFloat_AsDouble(item);
Py_DECREF(item);
Py_DECREF(f_item);
}
return none();
}
PyObject * listToDoubleArray(PyObject *list_obj, double *arr, unsigned n) {
PyObject *item, *f_item;
unsigned pylist_len = (unsigned) PyList_Size(list_obj);
unsigned i;
if (pylist_len != n) {
PyErr_SetString(PyExc_IndexError, "list index out of range");
return 0L;
}
for (i = 0; i < n; ++i) {
item = PyList_GetItem(list_obj, i);
if (item == 0L) {
return 0L;
}
Py_INCREF(item);
f_item = PyNumber_Float(item);
if (f_item == 0L) {
Py_DECREF(item);
return 0L;
}
arr[i] = PyFloat_AsDouble(item);
Py_DECREF(item);
Py_DECREF(f_item);
}
return none();
}
static PyObject *
SigTo_setValue(SigTo *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->value);
if (isNumber == 1) {
self->value = PyNumber_Float(tmp);
self->modebuffer[2] = 0;
}
else {
self->value = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->value, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->value_stream);
self->value_stream = (Stream *)streamtmp;
self->modebuffer[2] = 1;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *py_ue_sborder_set_padding(ue_PySBorder *self, PyObject * args)
{
ue_py_slate_cast(SBorder);
PyObject *py_padding;
if (!PyArg_ParseTuple(args, "O:set_padding", &py_padding))
{
return nullptr;
}
FMargin *margin = ue_py_check_struct<FMargin>(py_padding);
if (!margin)
{
if (!PyNumber_Check(py_padding))
{
return PyErr_Format(PyExc_Exception, "argument is not a FMargin or a number");
}
PyObject *py_float = PyNumber_Float(py_padding);
FMargin new_margin(PyFloat_AsDouble(py_float));
margin = &new_margin;
Py_DECREF(py_float);
}
py_SBorder->SetPadding(*margin);
Py_RETURN_SLATE_SELF;
}
static PyObject *
Chorus_setMix(Chorus *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->mix);
if (isNumber == 1) {
self->mix = PyNumber_Float(tmp);
self->modebuffer[4] = 0;
}
else {
self->mix = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->mix, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->mix_stream);
self->mix_stream = (Stream *)streamtmp;
self->modebuffer[4] = 1;
}
(*self->mode_func_ptr)(self);
Py_INCREF(Py_None);
return Py_None;
}
NUITKA_MAY_BE_UNUSED static PyObject *TO_FLOAT( PyObject *value )
{
PyObject *result;
#if PYTHON_VERSION < 300
if ( PyString_CheckExact( value ) )
{
result = PyFloat_FromString( value, NULL );
}
#else
if ( PyUnicode_CheckExact( value ) )
{
result = PyFloat_FromString( value );
}
#endif
else
{
result = PyNumber_Float( value );
}
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
}
static PyObject *
FourBandMain_setFreq3(FourBandMain *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->freq3);
if (isNumber == 1) {
self->freq3 = PyNumber_Float(tmp);
self->modebuffer[2] = 0;
}
else {
self->freq3 = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->freq3, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->freq3_stream);
self->freq3_stream = (Stream *)streamtmp;
self->modebuffer[2] = 1;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
BandSplitter_setQ(BandSplitter *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->q);
if (isNumber == 1) {
self->q = PyNumber_Float(tmp);
self->modebuffer[0] = 0;
BandSplitter_compute_variables((BandSplitter *)self, PyFloat_AS_DOUBLE(self->q));
}
else {
self->q = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->q, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->q_stream);
self->q_stream = (Stream *)streamtmp;
self->modebuffer[0] = 1;
}
(*self->mode_func_ptr)(self);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
OscBank_setArnda(OscBank *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->arnda);
if (isNumber == 1) {
self->arnda = PyNumber_Float(tmp);
self->modebuffer[8] = 0;
}
else {
self->arnda = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->arnda, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->arnda_stream);
self->arnda_stream = (Stream *)streamtmp;
self->modebuffer[8] = 1;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
NewMatrix_setMatrix(NewMatrix *self, PyObject *value)
{
int i, j;
PyObject *innerlist;
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the list attribute.");
return PyInt_FromLong(-1);
}
if (! PyList_Check(value)) {
PyErr_SetString(PyExc_TypeError, "The matrix value value must be a list.");
return PyInt_FromLong(-1);
}
int height = PyList_Size(value);
int width = PyList_Size(PyList_GetItem(value, 0));
if (height != self->height || width != self->width) {
PyErr_SetString(PyExc_TypeError, "New matrix must be of the same size as actual matrix.");
return PyInt_FromLong(-1);
}
for(i=0; i<self->height; i++) {
innerlist = PyList_GetItem(value, i);
for (j=0; j<self->width; j++) {
self->data[i][j] = PyFloat_AS_DOUBLE(PyNumber_Float(PyList_GET_ITEM(innerlist, j)));
}
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
Harmonizer_setFeedback(Harmonizer *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
if (arg == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->feedback);
if (isNumber == 1) {
self->feedback = PyNumber_Float(tmp);
self->modebuffer[3] = 0;
}
else {
self->feedback = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->feedback, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->feedback_stream);
self->feedback_stream = (Stream *)streamtmp;
self->modebuffer[3] = 1;
}
(*self->mode_func_ptr)(self);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
OscBank_setArndf(OscBank *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
ASSERT_ARG_NOT_NULL
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->arndf);
if (isNumber == 1) {
self->arndf = PyNumber_Float(tmp);
self->modebuffer[7] = 0;
}
else {
self->arndf = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->arndf, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->arndf_stream);
self->arndf_stream = (Stream *)streamtmp;
self->modebuffer[7] = 1;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *NumberValue(PyObject *self, PyObject *args)
{
PyObject *object;
PyObject *result = NULL;
if (!PyArg_ParseTuple(args, "O:NumberValue", &object))
return NULL;
result = PyNumber_Float(object);
if (result)
return result;
PyErr_Clear();
if (PyString_Check(object) || PyUnicode_Check(object))
return string_to_number(object);
/* convert it to a string */
object = object_to_string(object);
if (object) {
result = string_to_number(object);
Py_DECREF(object);
}
else result = NULL;
return result;
}
/*
* READER
*/
static int
parse_save_field(ReaderObj *self)
{
PyObject *field;
field = PyString_FromStringAndSize(self->field, self->field_len);
if (field == NULL)
return -1;
self->field_len = 0;
if (self->numeric_field) {
PyObject *tmp;
self->numeric_field = 0;
tmp = PyNumber_Float(field);
if (tmp == NULL) {
Py_DECREF(field);
return -1;
}
Py_DECREF(field);
field = tmp;
}
PyList_Append(self->fields, field);
Py_DECREF(field);
return 0;
}
/*
* READER
*/
static int
parse_save_field(ReaderObj *self)
{
PyObject *field;
field = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND,
(void *) self->field, self->field_len);
if (field == NULL)
return -1;
self->field_len = 0;
if (self->numeric_field) {
PyObject *tmp;
self->numeric_field = 0;
tmp = PyNumber_Float(field);
Py_DECREF(field);
if (tmp == NULL)
return -1;
field = tmp;
}
if (PyList_Append(self->fields, field) < 0) {
Py_DECREF(field);
return -1;
}
Py_DECREF(field);
return 0;
}
static PyObject *
LFO_setSharp(LFO *self, PyObject *arg)
{
PyObject *tmp, *streamtmp;
ASSERT_ARG_NOT_NULL
int isNumber = PyNumber_Check(arg);
tmp = arg;
Py_INCREF(tmp);
Py_DECREF(self->sharp);
if (isNumber == 1) {
self->sharp = PyNumber_Float(tmp);
self->modebuffer[3] = 0;
}
else {
self->sharp = tmp;
streamtmp = PyObject_CallMethod((PyObject *)self->sharp, "_getStream", NULL);
Py_INCREF(streamtmp);
Py_XDECREF(self->sharp_stream);
self->sharp_stream = (Stream *)streamtmp;
self->modebuffer[3] = 1;
}
(*self->mode_func_ptr)(self);
Py_INCREF(Py_None);
return Py_None;
}
bool GetDoubleFromPyObject(PyObject* object, double* val)
{
if(!val || !object) return false;
if( PyFloat_Check( object ) )
{
*val = PyFloat_AS_DOUBLE( object );
return true;
}
if( PyInt_Check( object ) )
{
*val = static_cast<double>( PyInt_AS_LONG( object ) );
return true;
}
PyObject* floatObject = PyNumber_Float(object);
if(floatObject)
{
*val = PyFloat_AS_DOUBLE( floatObject );
Py_DECREF(floatObject);
return true;
}
PyErr_Clear();
return false;
}
inline FloatPoint coerce_FloatPoint(PyObject* obj) {
// Fast method if the Point is a real FloatPoint or Point type.
PyTypeObject* t = get_FloatPointType();
if (t == 0) {
PyErr_SetString(PyExc_RuntimeError, "Couldn't get FloatPoint type.");
throw std::runtime_error("Couldn't get FloatPoint type.");
}
if (PyObject_TypeCheck(obj, t)) {
return FloatPoint(*(((FloatPointObject*)obj)->m_x));
}
PyTypeObject* t2 = get_PointType();
if (t2 == 0) {
PyErr_SetString(PyExc_RuntimeError, "Couldn't get Point type.");
throw std::runtime_error("Couldn't get Point type.");
}
if (PyObject_TypeCheck(obj, t2))
return FloatPoint(*(((PointObject*)obj)->m_x));
PyObject* py_x0 = NULL;
PyObject* py_y0 = NULL;
PyObject* py_x1 = NULL;
PyObject* py_y1 = NULL;
// Treat 2-element sequences as Points.
if (PySequence_Check(obj)) {
if (PySequence_Length(obj) == 2) {
py_x0 = PySequence_GetItem(obj, 0);
py_x1 = PyNumber_Float(py_x0);
if (py_x1 != NULL) {
double x = PyFloat_AsDouble(py_x1);
Py_DECREF(py_x1);
py_y0 = PySequence_GetItem(obj, 1);
py_y1 = PyNumber_Float(py_y0);
if (py_y1 != NULL) {
double y = PyFloat_AsDouble(py_y1);
Py_DECREF(py_y1);
return FloatPoint(x, y);
}
}
}
}
PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "Argument is not a FloatPoint (or convertible to one.)");
throw std::invalid_argument("Argument is not a FloatPoint (or convertible to one.)");
}
static PyObject *py_ue_fslate_style_set_set(ue_PyFSlateStyleSet *self, PyObject * args)
{
char *name;
PyObject *py_value;
if (!PyArg_ParseTuple(args, "sO:set", &name, &py_value))
return NULL;
FSlateSound *slate_sound = ue_py_check_struct<FSlateSound>(py_value);
if (slate_sound)
{
self->style_set->Set(FName(name), *slate_sound);
Py_RETURN_NONE;
}
FSlateBrush *slate_brush = ue_py_check_struct<FSlateBrush>(py_value);
if (slate_brush)
{
self->style_set->Set(FName(name), slate_brush);
Py_RETURN_NONE;
}
FSlateColor *slate_color = ue_py_check_struct<FSlateColor>(py_value);
if (slate_brush)
{
self->style_set->Set(FName(name), *slate_color);
Py_RETURN_NONE;
}
FSlateFontInfo *slate_font = ue_py_check_struct<FSlateFontInfo>(py_value);
if (slate_font)
{
self->style_set->Set(FName(name), *slate_font);
Py_RETURN_NONE;
}
ue_PyFLinearColor *py_linear_color = py_ue_is_flinearcolor(py_value);
if (py_linear_color)
{
self->style_set->Set(FName(name), py_linear_color->color);
Py_RETURN_NONE;
}
ue_PyFColor *py_color = py_ue_is_fcolor(py_value);
if (py_color)
{
self->style_set->Set(FName(name), py_color->color);
Py_RETURN_NONE;
}
if (PyNumber_Check(py_value))
{
PyObject *py_float = PyNumber_Float(py_value);
self->style_set->Set(FName(name), (float)PyFloat_AsDouble(py_float));
Py_DECREF(py_float);
Py_RETURN_NONE;
}
return PyErr_Format(PyExc_ValueError, "unsupported value type");
}
static PyObject *
to_float(PyObject *self, PyObject *arg)
{
if (arg == Py_None)
Py_RETURN_NONE;
return PyNumber_Float(arg);
}
static bool coord_from_py_noerr(PyObject* obj, coord& c){
if (!PyNumber_Check(obj)){
return false;
}
PyObject* pythonFloat = PyNumber_Float(obj);
c = PyFloat_AsDouble(pythonFloat);
return true;
}
static int Bar_setbounds(BarObject *self, PyObject *value, void *closure) {
int i;
double lb=0.0, ub=0.0;
PyObject *lo, *uo;
void (*bounder)(glp_prob*,int,int,double,double) = NULL;
if (!Bar_Valid(self, 1)) return -1;
i = Bar_Index(self)+1;
bounder = Bar_Row(self) ? glp_set_row_bnds : glp_set_col_bnds;
if (value==NULL || value==Py_None) {
// We want it unbounded and free.
bounder(LP, i, GLP_FR, 0.0, 0.0);
return 0;
}
if (PyNumber_Check(value)) {
// We want an equality fixed bound.
value = PyNumber_Float(value);
if (!value) return -1;
lb = PyFloat_AsDouble(value);
Py_DECREF(value);
if (PyErr_Occurred()) return -1;
bounder(LP, i, GLP_FX, lb, lb);
return 0;
}
char t_error[] = "bounds must be set to None, number, or pair of numbers";
if (!PyTuple_Check(value) || PyTuple_GET_SIZE(value)!=2) {
PyErr_SetString(PyExc_TypeError, t_error);
return -1;
}
// Get the lower and upper object. These references are borrowed.
lo = PyTuple_GetItem(value, 0);
uo = PyTuple_GetItem(value, 1);
if ((lo!=Py_None && !PyNumber_Check(lo)) ||
(uo!=Py_None && !PyNumber_Check(uo))) {
PyErr_SetString(PyExc_TypeError, t_error);
return -1;
}
if (lo==Py_None) lo=NULL; else lb=PyFloat_AsDouble(lo);
if (PyErr_Occurred()) return -1;
if (uo==Py_None) uo=NULL; else ub=PyFloat_AsDouble(uo);
if (PyErr_Occurred()) return -1;
if (!lo && !uo) bounder(LP, i, GLP_FR, 0.0, 0.0);
else if (!uo) bounder(LP, i, GLP_LO, lb, 0.0);
else if (!lo) bounder(LP, i, GLP_UP, 0.0, ub);
else if (lb<=ub) bounder(LP, i, lb==ub ? GLP_FX : GLP_DB, lb, ub);
else {
PyErr_SetString(PyExc_ValueError, "lower bound cannot exceed upper bound");
return -1;
}
return 0;
}
void pb_num_feature::add_feature(
const std::string& key,
double value,
std::vector<std::pair<std::string, double> >& ret_fv) const {
scoped_gil lk;
pb_object pkey(pb_unicode_from_string(key));
PB_CHECK(pkey,
"cannot convert input key to Python object: " << key);
pb_object pval(PyFloat_FromDouble(value));
PB_CHECK(pval,
"cannot convert input value to Python object for key: " << key);
pb_object ret(PyObject_CallMethodObjArgs(
ins_.get(),
method_.get(),
pkey.get(),
pval.get(),
NULL));
PB_CHECK(ret,
name_ << " method cannot be called");
PB_CHECK(PyList_CheckExact(ret.get()),
name_ << " method returned non-list type: " << pb_str(ret.get()));
size_t size = PyList_Size(ret.get());
for (size_t i = 0; i < size; ++i) {
PyObject* tpl = PyList_GetItem(ret.get(), i);
PB_CHECK(tpl,
"item " << i << " cannot be accessed: "
<< pb_str(ret.get()));
PB_CHECK(PyTuple_CheckExact(tpl),
"list must not contain non-tuple: " << pb_str(tpl));
PB_CHECK(PyTuple_Size(tpl) == 2,
"tuple length must be 2: " << pb_str(tpl));
PyObject* f_key = PyTuple_GetItem(tpl, 0);
PyObject* f_val = PyTuple_GetItem(tpl, 1);
PB_CHECK(PyUnicode_CheckExact(f_key),
"feature key must be a unicode string: " << pb_str(tpl));
PB_CHECK(PyNumber_Check(f_val),
"feature value must be a number: " << pb_str(tpl));
pb_object f_key_enc(PyUnicode_AsUTF8String(f_key));
PB_CHECK(f_key_enc,
"feature key cannot be encoded as UTF-8: "
<< pb_str(tpl));
pb_object f_val_float(PyNumber_Float(f_val));
PB_CHECK(f_val_float,
"value cannot be converted as float: " << pb_str(tpl));
ret_fv.push_back(std::make_pair(
std::string(PyBytes_AsString(f_key_enc.get())),
PyFloat_AsDouble(f_val_float.get())));
}
}
static PyObject*
tp_new (PyTypeObject *type, PyObject *args, PyObject *kwds) {
SELF self;
PySoy_scenes_Scene_Object* scene;
PySoy_bodies_Body_Object* controlled;
PySoy_atoms_Position_Object* dest;
float radius, speed, granularity = -1.0f, fuzziness = -1.0f;
int updates = FALSE, paused = FALSE;
PyObject* bounds = Py_None;
static char *kw[] = {"scene", "controlled", "dest", "speed", "granularity", "fuzziness", "bounds", "updates", "paused", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!ff|fOii", kw,
&PySoy_scenes_Scene_Type, &scene,
&PySoy_bodies_Body_Type, &controlled,
&PySoy_atoms_Position_Type, &dest,
&speed,
&granularity,
&fuzziness,
&bounds,
&updates,
&paused))
return NULL;
if (fuzziness == -1.0f) {
fuzziness = speed/10000.0f;
} else if (fuzziness < 0.0f) {
PyErr_SetString(PyExc_ValueError, "'fuzziness' must be a number greater than 0");
return NULL;
}
self = (SELF) PyType_GenericNew(type, args, kwds);
if (!self)
return NULL;
if (bounds == Py_None) {
self->g = soy_controllers_space_navigator_new(scene->g, controlled->g, speed, fuzziness, granularity, dest->g, updates, paused);
} else if (PySoy_atoms_Size_Check(bounds)) {
soycontrollersgraphSpace* graph = soy_controllers_graph_space_new_with_size(scene->g, granularity, ((PySoy_atoms_Size_Object*)bounds)->g,NULL);
self->g = soy_controllers_space_navigator_new_with_graph(scene->g, controlled->g, speed, fuzziness, (soycontrollersgraphIGraph*) graph, dest->g, updates, paused);
} else if (PyNumber_Check(bounds)) {
PyObject* flt = PyNumber_Float(bounds);
if (flt == NULL)
return NULL;
radius = (float)PyFloat_AsDouble(flt);
Py_DECREF(flt);
if (PyErr_Occurred()) { return NULL; }
soycontrollersgraphSpace* graph = soy_controllers_graph_space_new_with_radius(scene->g, granularity, radius,NULL);
self->g = soy_controllers_space_navigator_new_with_graph(scene->g, controlled->g, speed, fuzziness, (soycontrollersgraphIGraph*) graph, dest->g, updates, paused);
} else {
PyErr_SetString(PyExc_ValueError, "'bounds' must be either a number greater then 0 or a soy.atoms.Size");
return NULL;
}
return (PyObject*) self;
}
/*
* new_points
*
* Stores the items of a Numerical Python array or a Python sequence in a
* C vector of double values. Returns the number of elements or -1.
* The C vector must be freed with g_free().
*/
static gint
new_points(PyObject *sequence, gdouble **out_points, int *out_array_type)
{
int n = 0;
gdouble *points = NULL;
*out_array_type = PyArray_NOTYPE;
#ifndef WITHOUT_NUMPY
if (PyArray_Check(sequence)) {
PyArrayObject *array;
array = (PyArrayObject *)
PyArray_ContiguousFromObject(sequence, PyArray_DOUBLE, 1, 1);
if (!array)
return -1;
n = array->dimensions[0];
points = g_new(gdouble, n);
memcpy(points, array->data, n * sizeof(double));
Py_DECREF(array);
*out_array_type = ((PyArrayObject *) sequence)->descr->type_num;
} else
#endif
if (PySequence_Check(sequence)) {
n = PySequence_Length(sequence);
if (n > 0) {
int i;
points = g_new(gdouble, n);
for (i = 0; i < n; ++i) {
PyObject *item, *value;
item = PySequence_GetItem(sequence, i);
if (PyFloat_Check(item)) {
points[i] = PyFloat_AS_DOUBLE(item);
} else if (PyNumber_Check(item)
&& (value = PyNumber_Float(item))) {
points[i] = PyFloat_AS_DOUBLE(value);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_TypeError,
"sequence items must be numbers");
Py_DECREF(item);
g_free(points);
points = NULL;
return -1;
}
Py_DECREF(item);
}
}
} else if (sequence != Py_None) {
PyErr_SetString(PyExc_TypeError, "argument must be sequence or None");
return -1;
}
*out_points = points;
return n;
}
static PyObject *string_to_number(PyObject *string)
{
PyObject *result = PyNumber_Float(string);
if (result == NULL) {
PyErr_Clear();
Py_INCREF(PyNumber_NaN);
result = PyNumber_NaN;
}
return result;
}
