static int doquery() { int ret = 0; char buf[100]; Uint8 b_lo_buffer[NdbIndexStat::BoundBufferBytes]; Uint8 b_hi_buffer[NdbIndexStat::BoundBufferBytes]; NdbIndexStat::Bound b_lo(g_is, b_lo_buffer); NdbIndexStat::Bound b_hi(g_is, b_hi_buffer); do { NdbIndexStat::Range r(b_lo, b_hi); Uint8 s_buffer[NdbIndexStat::StatBufferBytes]; NdbIndexStat::Stat s(s_buffer); for (int n = 0; n < _query; n++) { g_is->reset_range(r); for (int i = 0; i <= 1; i++) { NdbIndexStat::Bound& b = (i == 0 ? b_lo : b_hi); if (ndb_rand() % 3 != 0) { if (ndb_rand() % 3 != 0) { Uint32 x = ndb_rand(); CHK2(g_is->add_bound(b, &x) == 0, g_is->getNdbError()); } else { CHK2(g_is->add_bound_null(b) == 0, g_is->getNdbError()); } bool strict = (ndb_rand() % 2 == 0); g_is->set_bound_strict(b, strict); } } CHK2(ret == 0, "failed"); CHK2(g_is->finalize_range(r) == 0, g_is->getNdbError()); CHK2(g_is->query_stat(r, s) == 0, g_is->getNdbError()); double rir = -1.0; NdbIndexStat::get_rir(s, &rir); g_info << "rir: " << format(rir, buf) << endl; } CHK2(ret == 0, "failed"); } while (0); return ret; }
/** the gateway function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* [t, b] = ddm_rand_full(mu, sig2, b_lo, b_up, delta_t, n[, inv_leak[, seed]]) */ /* Check argument number */ if (nlhs != 2) { mexErrMsgIdAndTxt("ddm_rand_full:WrongOutputs", "Wrong number of output arguments"); } if (nrhs < 6) { mexErrMsgIdAndTxt("ddm_rand_full:WrongInputs", "Too few input arguments"); } /* Process first 8 arguments */ if (!MEX_ARGIN_IS_REAL_VECTOR(0)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "First input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(1)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Second input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(2)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Third input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(3)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Fourth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_DOUBLE(4)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Fifth input argument expected to be a double"); if (!MEX_ARGIN_IS_REAL_DOUBLE(5)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Sixth input argument expected to be a double"); if (nrhs >= 7 && !MEX_ARGIN_IS_REAL_DOUBLE(6)) mexErrMsgIdAndTxt("ddm_rand_sym:WrongInput", "Seventh input argument expected to be a double"); if (nrhs >= 8 && !MEX_ARGIN_IS_REAL_DOUBLE(7)) mexErrMsgIdAndTxt("ddm_rand_sym:WrongInput", "Eighth input argument expected to be a double"); int mu_size = std::max(mxGetN(prhs[0]), mxGetM(prhs[0])); int sig2_size = std::max(mxGetN(prhs[1]), mxGetM(prhs[1])); int b_lo_size = std::max(mxGetN(prhs[2]), mxGetM(prhs[2])); int b_up_size = std::max(mxGetN(prhs[3]), mxGetM(prhs[3])); ExtArray mu(ExtArray::shared_noowner(mxGetPr(prhs[0])), mu_size); ExtArray sig2(ExtArray::shared_noowner(mxGetPr(prhs[1])), sig2_size); ExtArray b_lo(ExtArray::shared_noowner(mxGetPr(prhs[2])), b_lo_size); ExtArray b_up(ExtArray::shared_noowner(mxGetPr(prhs[3])), b_up_size); ExtArray b_lo_deriv = ExtArray::const_array(0.0); ExtArray b_up_deriv = ExtArray::const_array(0.0); double delta_t = mxGetScalar(prhs[4]); int n = (int) mxGetScalar(prhs[5]); if (delta_t <= 0.0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "delta_t needs to be larger than 0.0"); if (n <= 0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "n needs to be larger than 1"); bool has_leak = false; double inv_leak = 0.0; if (nrhs >= 7) { inv_leak = mxGetScalar(prhs[6]); has_leak = (inv_leak != 0.0); if (inv_leak < 0.0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "inv_leak needs to be non-negative"); } int rngseed = 0; if (nrhs >= 8) rngseed = (int) mxGetScalar(prhs[7]); if (nrhs > 8) mexErrMsgIdAndTxt("ddm_rand_full:WrongInputs", "Too many input arguments"); /* reserve space for output */ plhs[0] = mxCreateDoubleMatrix(1, n, mxREAL); plhs[1] = mxCreateLogicalMatrix(1, n); double* t = mxGetPr(plhs[0]); mxLogical* b = mxGetLogicals(plhs[1]); /* perform sampling */ DMBase* dm = nullptr; if (has_leak) dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, inv_leak); else dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t); DMBase::rngeng_t rngeng; if (rngseed == 0) rngeng.seed(std::random_device()()); else rngeng.seed(rngseed); for (int i = 0; i < n; ++i) { DMSample s = dm->rand(rngeng); t[i] = s.t(); b[i] = s.upper_bound() ? 1 : 0; } delete dm; }
/* method (t, b) = rand_asym(mu, b_lo, b_up, dt, n[, seed]) */ static PyObject* ddmmod_rand_asym(PyObject* self, PyObject* args) { /* process arguments */ PyArrayObject *py_mu, *py_b_lo, *py_b_up; double dt; int n, rngseed = 0; if (!PyArg_ParseTuple(args, "O!O!O!di|i", &PyArray_Type, &py_mu, &PyArray_Type, &py_b_lo, &PyArray_Type, &py_b_up, &dt, &n, &rngseed)) return NULL; if (!(is1DDoubleArray(py_mu) && is1DDoubleArray(py_b_lo) && is1DDoubleArray(py_b_up))) return NULL; if (dt <= 0.0) { PyErr_SetString(PyExc_ValueError, "dt needs to be larger than 0"); return NULL; } if (n <= 0) { PyErr_SetString(PyExc_ValueError, "n needs to be larger than 0"); return NULL; } ExtArray mu(ExtArray::shared_noowner((double*) PyArray_DATA(py_mu)), PyArray_DIM(py_mu, 0)); ExtArray b_lo(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_lo)), PyArray_DIM(py_b_lo, 0)); ExtArray b_up(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_up)), PyArray_DIM(py_b_up, 0)); if (b_lo[0] >= 0.0) { PyErr_SetString(PyExc_ValueError, "b_lo[0] needs to be negative"); return NULL; } if (b_up[0] <= 0.0) { PyErr_SetString(PyExc_ValueError, "b_up[0] needs to be positive"); return NULL; } /* get output length and reserve space */ npy_intp out_size[1] = { n }; PyObject* py_t = PyArray_SimpleNew(1, out_size, NPY_DOUBLE); if (py_t == NULL) return NULL; PyObject* py_b = PyArray_SimpleNew(1, out_size, NPY_BOOL); if (py_b == NULL) { Py_DECREF(py_t); return NULL; } npy_double* t = (npy_double*) PyArray_DATA((PyArrayObject*) py_t); npy_bool* b = (npy_bool*) PyArray_DATA((PyArrayObject*) py_b); /* perform sampling */ DMBase* dm = DMBase::create(mu, ExtArray::const_array(1.0), b_lo, b_up, ExtArray::const_array(0.0), ExtArray::const_array(0.0), dt); DMBase::rngeng_t rngeng; if (rngseed == 0) rngeng.seed(std::random_device()()); else rngeng.seed(rngseed); for (int i = 0; i < n; ++i) { DMSample s = dm->rand(rngeng); t[i] = s.t(); b[i] = s.upper_bound() ? NPY_TRUE : NPY_FALSE; } delete dm; /* create tuple to return */ PyObject* py_tuple = PyTuple_New(2); if (py_tuple == NULL) goto memory_fail; PyTuple_SET_ITEM(py_tuple, 0, py_t); PyTuple_SET_ITEM(py_tuple, 1, py_b); return py_tuple; memory_fail: Py_DECREF(py_t); Py_DECREF(py_b); PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; }
/* method fpt_full(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, dt, tmax, * [inv_leak, mnorm]) */ static PyObject* ddmmod_fpt_full(PyObject* self, PyObject* args, PyObject* keywds) { /* process arguments */ static char* kwlist[] = {"mu", "sig2", "b_lo", "b_up", "b_lo_deriv", "b_up_deriv", "dt", "tmax", "inv_leak", "mnorm", NULL}; PyArrayObject *py_mu, *py_sig2, *py_b_lo, *py_b_up, *py_b_lo_deriv, *py_b_up_deriv; double dt, t_max, inv_leak = 0.0; PyObject* mnorm_obj = NULL; if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!O!O!O!O!O!dd|dO", kwlist, &PyArray_Type, &py_mu, &PyArray_Type, &py_sig2, &PyArray_Type, &py_b_lo, &PyArray_Type, &py_b_up, &PyArray_Type, &py_b_lo_deriv, &PyArray_Type, &py_b_up_deriv, &dt, &t_max, &inv_leak, &mnorm_obj)) return NULL; if (!(is1DDoubleArray(py_mu) && is1DDoubleArray(py_sig2) && is1DDoubleArray(py_b_lo) && is1DDoubleArray(py_b_up) && is1DDoubleArray(py_b_lo_deriv) && is1DDoubleArray(py_b_up_deriv))) return NULL; if (dt <= 0.0) { PyErr_SetString(PyExc_ValueError, "dt needs to be larger than 0"); return NULL; } if (t_max <= 0.0) { PyErr_SetString(PyExc_ValueError, "tmax needs to be larger than 0"); return NULL; } if (inv_leak < 0.0) { PyErr_SetString(PyExc_ValueError, "inv_leak needs to be non-negative"); return NULL; } bool mnorm_bool = (mnorm_obj != NULL && PyObject_IsTrue(mnorm_obj) == 1); ExtArray mu(ExtArray::shared_noowner((double*) PyArray_DATA(py_mu)), PyArray_DIM(py_mu, 0)); ExtArray sig2(ExtArray::shared_noowner((double*) PyArray_DATA(py_sig2)), PyArray_DIM(py_sig2, 0)); ExtArray b_lo(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_lo)), PyArray_DIM(py_b_lo, 0)); ExtArray b_up(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_up)), PyArray_DIM(py_b_up, 0)); ExtArray b_lo_deriv(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_lo_deriv)), PyArray_DIM(py_b_lo_deriv, 0)); ExtArray b_up_deriv(ExtArray::shared_noowner((double*) PyArray_DATA(py_b_up_deriv)), PyArray_DIM(py_b_up_deriv, 0)); /* get output length and reserve space */ int n_max = (int) ceil(t_max / dt); npy_intp out_size[1] = { n_max }; PyObject* py_g1 = PyArray_SimpleNew(1, out_size, NPY_DOUBLE); if (py_g1 == NULL) return NULL; PyObject* py_g2 = PyArray_SimpleNew(1, out_size, NPY_DOUBLE); if (py_g2 == NULL) { Py_DECREF(py_g1); return NULL; } ExtArray g1(ExtArray::shared_noowner( (double*) PyArray_DATA((PyArrayObject*) py_g1)), n_max); ExtArray g2(ExtArray::shared_noowner( (double*) PyArray_DATA((PyArrayObject*) py_g2)), n_max); /* compute fpt */ DMBase* dm = nullptr; if (inv_leak > 0.0) dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, dt, inv_leak); else dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, dt); dm->pdfseq(n_max, g1, g2); if (mnorm_bool) dm->mnorm(g1, g2); delete dm; /* create tuple to return */ PyObject* py_tuple = PyTuple_New(2); if (py_tuple == NULL) goto memory_fail; PyTuple_SET_ITEM(py_tuple, 0, py_g1); PyTuple_SET_ITEM(py_tuple, 1, py_g2); return py_tuple; memory_fail: Py_DECREF(py_g1); Py_DECREF(py_g2); PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; }
/** the gateway function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* [g1, g2] = ddm_fpt_full(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, t_max, [leak]) */ /* Check argument number */ if (nlhs != 2) { mexErrMsgIdAndTxt("ddm_fpt_full:WrongOutputs", "Wrong number of output arguments"); } if (nrhs < 8) { mexErrMsgIdAndTxt("ddm_fpt_full:WrongInputs", "Too few input arguments"); } /* Process first 8 arguments */ if (!MEX_ARGIN_IS_REAL_VECTOR(0)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "First input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(1)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Second input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(2)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Third input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(3)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Fourth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(4)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Fifth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(5)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Sixth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_DOUBLE(6)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Seventh input argument expected to be a double"); if (!MEX_ARGIN_IS_REAL_DOUBLE(7)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Eight input argument expected to be a double"); int mu_size = std::max(mxGetN(prhs[0]), mxGetM(prhs[0])); int sig2_size = std::max(mxGetN(prhs[1]), mxGetM(prhs[1])); int b_lo_size = std::max(mxGetN(prhs[2]), mxGetM(prhs[2])); int b_up_size = std::max(mxGetN(prhs[3]), mxGetM(prhs[3])); int b_lo_deriv_size = std::max(mxGetN(prhs[4]), mxGetM(prhs[4])); int b_up_deriv_size = std::max(mxGetN(prhs[5]), mxGetM(prhs[5])); ExtArray mu(ExtArray::shared_noowner(mxGetPr(prhs[0])), mu_size); ExtArray sig2(ExtArray::shared_noowner(mxGetPr(prhs[1])), sig2_size); ExtArray b_lo(ExtArray::shared_noowner(mxGetPr(prhs[2])), b_lo_size); ExtArray b_up(ExtArray::shared_noowner(mxGetPr(prhs[3])), b_up_size); ExtArray b_lo_deriv(ExtArray::shared_noowner(mxGetPr(prhs[4])), 0.0, b_lo_deriv_size); ExtArray b_up_deriv(ExtArray::shared_noowner(mxGetPr(prhs[5])), 0.0, b_up_deriv_size); double delta_t = mxGetScalar(prhs[6]); double t_max = mxGetScalar(prhs[7]); if (delta_t <= 0.0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "delta_t needs to be larger than 0.0"); if (t_max <= delta_t) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "t_max needs to be at least as large as delta_t"); /* Process possible 9th non-string argument */ int cur_argin = 8; bool has_leak = false; double inv_leak = 0.0; if (nrhs > cur_argin && !mxIsChar(prhs[cur_argin])) { if (!MEX_ARGIN_IS_REAL_DOUBLE(cur_argin)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Ninth input argument expected to be a double"); inv_leak = mxGetScalar(prhs[cur_argin]); if (inv_leak < 0.0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "inv_leak needs to be non-negative"); has_leak = (inv_leak != 0.0); ++cur_argin; } /* Process string arguments */ bool normalise_mass = false; if (nrhs > cur_argin) { char str_arg[6]; /* current only accept 'mnorm' string argument */ if (!mxIsChar(prhs[cur_argin])) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "String argument expected but not found"); if (mxGetString(prhs[cur_argin], str_arg, sizeof(str_arg)) == 1 || strcmp(str_arg, "mnorm") != 0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "\"mnorm\" string argument expected"); /* this needs to be followed by "yes" or "no" */ if (nrhs <= cur_argin + 1 || !mxIsChar(prhs[cur_argin + 1])) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "String expected after \"mnorm\""); if (mxGetString(prhs[cur_argin + 1], str_arg, sizeof(str_arg)) == 1 || (strcmp(str_arg, "yes") != 0 && strcmp(str_arg, "no") != 0)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "\"yes\" or \"no\" expected after \"mnorm\""); normalise_mass = (strcmp(str_arg, "yes") == 0); /* no arguments allowed after that */ if (nrhs > cur_argin + 2) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInputs", "Too many input arguments"); } /* reserve space for output */ int n = (int) ceil(t_max / delta_t); plhs[0] = mxCreateDoubleMatrix(1, n, mxREAL); plhs[1] = mxCreateDoubleMatrix(1, n, mxREAL); ExtArray g1(ExtArray::shared_noowner(mxGetPr(plhs[0])), n); ExtArray g2(ExtArray::shared_noowner(mxGetPr(plhs[1])), n); /* compute the pdf's */ DMBase* dm = nullptr; if (has_leak) dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, inv_leak); else dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t); dm->pdfseq(n, g1, g2); if (normalise_mass) dm->mnorm(g1, g2); delete dm; }