static int PyBobLearnMLPMachine_setInputDivision (PyBobLearnMLPMachineObject* self,
PyObject* o, void* /*closure*/) {
if (PyBob_NumberCheck(o)) {
double v = PyFloat_AsDouble(o);
if (PyErr_Occurred()) return -1;
self->cxx->setInputDivision(v);
return 0;
}
PyBlitzArrayObject* input_divide = 0;
if (!PyBlitzArray_Converter(o, &input_divide)) return -1;
auto input_divide_ = make_safe(input_divide);
if (input_divide->type_num != NPY_FLOAT64 || input_divide->ndim != 1) {
PyErr_Format(PyExc_TypeError, "`%s' only supports either a single float or 64-bit floats 1D arrays for property array `input_divide'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setInputDivision(*PyBlitzArrayCxx_AsBlitz<double,1>(input_divide));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `input_divide' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobLearnLinearMachine_setInputSubtraction
(PyBobLearnLinearMachineObject* self, PyObject* o, void* /*closure*/) {
PyBlitzArrayObject* input_subtract = 0;
if (!PyBlitzArray_Converter(o, &input_subtract)) return -1;
auto input_subtract_ = make_safe(input_subtract);
if (input_subtract->type_num != NPY_FLOAT64 || input_subtract->ndim != 1) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 64-bit floats 1D arrays for property array `input_subtract'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setInputSubtraction(*PyBlitzArrayCxx_AsBlitz<double,1>(input_subtract));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `input_subtract' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobLearnMLPMachine_setBiases (PyBobLearnMLPMachineObject* self,
PyObject* biases, void* /*closure*/) {
if (PyBob_NumberCheck(biases)){
double v = PyFloat_AsDouble(biases);
if (PyErr_Occurred()) return -1;
self->cxx->setBiases(v);
return 0;
}
if (!PyIter_Check(biases) && !PySequence_Check(biases)) {
PyErr_Format(PyExc_TypeError, "setting attribute `biases' of `%s' requires either a float or an iterable, but you passed `%s' which does not implement the iterator protocol", Py_TYPE(self)->tp_name, Py_TYPE(biases)->tp_name);
return -1;
}
/* Checks and converts all entries */
std::vector<blitz::Array<double,1> > biases_seq;
std::vector<boost::shared_ptr<PyBlitzArrayObject>> biases_seq_;
PyObject* iterator = PyObject_GetIter(biases);
if (!iterator) return -1;
auto iterator_ = make_safe(iterator);
while (PyObject* item = PyIter_Next(iterator)) {
auto item_ = make_safe(item);
PyBlitzArrayObject* bz = 0;
if (!PyBlitzArray_Converter(item, &bz)) {
PyErr_Format(PyExc_TypeError, "`%s' could not convert object of type `%s' at position %" PY_FORMAT_SIZE_T "d of input sequence into an array - check your input", Py_TYPE(self)->tp_name, Py_TYPE(item)->tp_name, biases_seq.size());
return -1;
}
if (bz->ndim != 1 || bz->type_num != NPY_FLOAT64) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 1D 64-bit float arrays for attribute `biases' (or any other object coercible to that), but at position %" PY_FORMAT_SIZE_T "d I have found an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, biases_seq.size(), bz->ndim, PyBlitzArray_TypenumAsString(bz->type_num));
Py_DECREF(bz);
return -1;
}
biases_seq_.push_back(make_safe(bz)); ///< prevents data deletion
biases_seq.push_back(*PyBlitzArrayCxx_AsBlitz<double,1>(bz)); ///< only a view!
}
if (PyErr_Occurred()) return -1;
try {
self->cxx->setBiases(biases_seq);
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `biases' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobLearnLinearMachine_setWeights (PyBobLearnLinearMachineObject* self,
PyObject* o, void* /*closure*/) {
PyBlitzArrayObject* weights = 0;
if (!PyBlitzArray_Converter(o, &weights)) return -1;
auto weights_ = make_safe(weights);
if (weights->type_num != NPY_FLOAT64 || weights->ndim != 2) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 64-bit floats 2D arrays for property array `weights'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setWeights(*PyBlitzArrayCxx_AsBlitz<double,2>(weights));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `weights' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int double2d_converter(PyObject *o, PyBlitzArrayObject **a) {
if (PyBlitzArray_Converter(o, a) == 0)
return 0;
// in this case, *a is set to a new reference
if ((*a)->type_num != NPY_FLOAT64 || (*a)->ndim != 2) {
PyErr_Format(PyExc_TypeError,
"cannot convert blitz::Array<%s,%" PY_FORMAT_SIZE_T
"d> to a blitz::Array<double,2>",
PyBlitzArray_TypenumAsString((*a)->type_num), (*a)->ndim);
return 0;
}
return 1;
}
