int
main(int argc, char** argv){
SndWave infile(argv[1], READ);
SndIn sig1(&infile,1);
SndIn sig2(&infile,2);
SndAiff output1(argv[2], OVERWRITE);
SndAiff output2(argv[3], OVERWRITE);
output1.SetOutput(1, &sig1);
output2.SetOutput(1, &sig1);
while(!infile.Eof()){
infile.Read();
sig1.DoProcess();
sig2.DoProcess();
output1.Write();
output2.Write();
}
return 0;
}
void ScenePlayTD::reload_map(){
Input::Signal sig("push_scene","Game");
Input::Signal sig2("pop_scene","Game");
sig2.sent();
sig.ex_data=new AOC::ScenePlayTD(map_name,glm::ivec3(1,1,1));
sig.sent();
}
void EMDHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, InputArray _descriptors2, OutputArray _costMatrix)
{
// size of the costMatrix with dummies //
Mat descriptors1=_descriptors1.getMat();
Mat descriptors2=_descriptors2.getMat();
int costrows = std::max(descriptors1.rows, descriptors2.rows)+nDummies;
_costMatrix.create(costrows, costrows, CV_32F);
Mat costMatrix=_costMatrix.getMat();
// Obtain copies of the descriptors //
cv::Mat scd1=descriptors1.clone();
cv::Mat scd2=descriptors2.clone();
// row normalization //
for(int i=0; i<scd1.rows; i++)
{
cv::Mat row = scd1.row(i);
scd1.row(i)/=(sum(row)[0]+FLT_EPSILON);
}
for(int i=0; i<scd2.rows; i++)
{
cv::Mat row = scd2.row(i);
scd2.row(i)/=(sum(row)[0]+FLT_EPSILON);
}
// Compute the Cost Matrix //
for(int i=0; i<costrows; i++)
{
for(int j=0; j<costrows; j++)
{
if (i<scd1.rows && j<scd2.rows)
{
cv::Mat sig1(scd1.cols,2,CV_32F), sig2(scd2.cols,2,CV_32F);
sig1.col(0)=scd1.row(i).t();
sig2.col(0)=scd2.row(j).t();
for (int k=0; k<sig1.rows; k++)
{
sig1.at<float>(k,1)=float(k);
}
for (int k=0; k<sig2.rows; k++)
{
sig2.at<float>(k,1)=float(k);
}
costMatrix.at<float>(i,j) = cv::EMD(sig1, sig2, flag);
}
else
{
costMatrix.at<float>(i,j) = defaultCost;
}
}
}
}
// Compute the mapping between linear array and the hypercube
// corresponding to all the trees.
void GeneratorTrees::ComputeCubeMapping()
{
assert(trees.length()>=1);
if (trees.length()==1) { // A single tree
ComputeOneGenMapping(map2array, trees[0]);
}
else { // more than one generator
// Compute the sub-mapping for every generator. Also prepare two hypercube
// signature objects for the index calculations, with the two ordering of
// the generators: one for the generators ordered by their index 0,1,2...
// and the other odred the generators by the order of their trees
Vec<long> dims1(INIT_SIZE,trees.length()), dims2(INIT_SIZE,trees.length());
Vec<Permut> genMappings(INIT_SIZE, trees.length());
for (long i=0; i<trees.length(); i++) {
dims1[i] = trees[i][0].getData().size;
ComputeOneGenMapping(genMappings[i], trees[i]);
}
getCubeDims(dims2);
CubeSignature sig1(dims1), sig2(dims2);
// Allocate space for the mapping
map2array.SetLength(sig1.getSize());
// Combine the generator perms to a single permutation over the cube
for (long i=0; i<map2array.length(); i++) {
long t=0;
for (long j1=0; j1<trees.length(); j1++) {
long j2 = trees[j1].getAuxKey();
long digit = sig1.getCoord(i,j1); // the j1 digit of i in base dims
digit = genMappings[j1][digit]; // apply the j1 permutation to it
t += digit * sig2.getProd(j2+1); // adds the permuted digit
}
map2array[i] = t;
}
}
// Compute the inverse permutation
map2cube.SetLength(map2array.length());
for (long i=0; i<map2array.length(); i++) map2cube[ map2array[i] ] = i;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
const size_t MAX_DEPTH = argc == 1 ? 10 : ACE_OS::atoi (argv[1]);
ACE_OS::atexit (exithook);
if (argc > 2)
ACE_Trace::set_nesting_indent (ACE_OS::atoi (argv[2]));
ACE_TRACE ("int ACE_TMAIN (int argc, ACE_TCHAR *argv[])");
ACE_Sig_Action sig1 ((ACE_SignalHandler) ACE_Trace::start_tracing,
SIGUSR1);
ACE_UNUSED_ARG (sig1);
ACE_Sig_Action sig2 ((ACE_SignalHandler) ACE_Trace::stop_tracing,
SIGUSR2);
ACE_UNUSED_ARG (sig2);
My_Task task (MAX_DEPTH);
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
int n_threads = argc > 3 ? ACE_OS::atoi (argv[3]) : 4;
if (task.activate (THR_BOUND | THR_DETACHED, n_threads) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"activate"),
-1);
// Wait for all the threads to exit.
ACE_Thread_Manager::instance ()->wait ();
#else
const int MAX_ITERATIONS = argc > 3 ? ACE_OS::atoi (argv[3]) : 10;
for (int i = 0; i < MAX_ITERATIONS; i++)
task.svc ();
#endif /* ACE_MT_SAFE */
// Destructor automatically called.
return 0;
}
/** 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;
}
std::complex<double> signal::correlation(const signal& other) const {
signal sig1(*this), sig2(other);
sig1 /= sig1.abs(); sig2 /= sig2.abs();
return sig1 ^ sig2;
}
//--------------------------------------------------------------------
void bridge_reg_stable(double *betap,
double *lambdap,
double *sig2p,
double *taup,
double *alphap,
const double *yp,
const double *Xp,
const double *sig2_shape,
const double *sig2_scale,
const double *nu_shape,
const double *nu_rate,
const double *alpha_a,
const double *alpha_b,
const double *true_sig2,
const double *true_tau,
const double *true_alpha,
const int *P,
const int *N,
const int *M,
const int *burn,
double *runtime,
const bool *ortho)
{
Matrix y(yp, *N, 1);
Matrix X(Xp, *N, *P);
Matrix beta (*P, 1, *M);
Matrix lambda(*P, 1, *M, 1.0);
Matrix sig2 ( 1, 1, *M);
Matrix tau ( 1, 1, *M);
Matrix alpha ( 1, 1, *M);
#ifdef USE_R
GetRNGstate();
#endif
if (!*ortho) {
*runtime = bridge_regression_stable(beta, lambda, sig2, tau, alpha,
y, X,
*sig2_shape, *sig2_scale,
*nu_shape, *nu_rate,
*alpha_a, *alpha_b,
*true_sig2, *true_tau, *true_alpha,
(uint)*burn);
}
else {
*runtime = bridge_regression_stable_ortho(beta, lambda, sig2, tau, alpha,
y, X,
*sig2_shape, *sig2_scale,
*nu_shape, *nu_rate,
*alpha_a, *alpha_b,
*true_sig2, *true_tau, *true_alpha,
(uint)*burn);
}
#ifdef USE_R
PutRNGstate();
#endif
// std::copy(&beta(0), &beta(0) + beta.vol(), betap);
MatrixFrame beta_mf (betap, *P, 1, *M);
MatrixFrame lambda_mf(lambdap, *P, 1, *M);
MatrixFrame sig2_mf (sig2p, 1, 1, *M);
MatrixFrame tau_mf (taup, 1, 1, *M);
MatrixFrame alpha_mf(alphap, 1, 1, *M);
beta_mf.copy(beta);
lambda_mf.copy(lambda);
sig2_mf.copy(sig2);
tau_mf.copy(tau);
alpha_mf.copy(alpha);
} // bridge_regression
void bridge_regression(double *betap,
double *up,
double *omegap,
double *shapep,
double *sig2p,
double *taup,
double *alphap,
const double *yp,
const double *Xp,
const double *sig2_shape,
const double *sig2_scale,
const double *nu_shape,
const double *nu_rate,
const double *alpha_a,
const double *alpha_b,
const double *true_sig2,
const double *true_tau,
const double *true_alpha,
const int *P,
const int *N,
const int *M,
const int *burn,
double *runtime,
const bool *ortho,
const int *betaburn,
const bool *use_hmc)
{
Matrix y(yp, *N, 1);
Matrix X(Xp, *N, *P);
Matrix beta(*P, 1, *M);
Matrix u (*P, 1, *M, 0.0);
Matrix omega(*P, 1, *M, 1.0);
Matrix shape(*P, 1, *M, 0.0);
Matrix sig2( 1, 1, *M);
Matrix tau ( 1, 1, *M);
Matrix alpha(1, 1, *M);
#ifdef USE_R
GetRNGstate();
#endif
if (!*ortho) {
*runtime = bridge_regression(beta, u, omega, shape, sig2, tau, alpha, y, X,
*sig2_shape, *sig2_scale,
*nu_shape, *nu_rate,
*alpha_a, *alpha_b,
*true_sig2, *true_tau, *true_alpha,
*burn, *betaburn, *use_hmc);
}
else {
*runtime = bridge_regression_ortho(beta, u, omega, shape, sig2, tau, alpha,
y, X,
*sig2_shape, *sig2_scale,
*nu_shape, *nu_rate,
*alpha_a, *alpha_b,
*true_sig2, *true_tau, *true_alpha,
*burn);
}
#ifdef USE_R
PutRNGstate();
#endif
MatrixFrame beta_mf (betap, *P, 1 , *M);
MatrixFrame u_mf (up , *P, 1, *M);
MatrixFrame omega_mf(omegap, *P, 1, *M);
MatrixFrame shape_mf(shapep, *P, 1, *M);
MatrixFrame sig2_mf (sig2p, 1 , 1 , *M);
MatrixFrame tau_mf (taup , 1 , 1 , *M);
MatrixFrame alpha_mf(alphap, 1, 1, *M);
beta_mf.copy(beta);
u_mf.copy(u);
omega_mf.copy(omega);
shape_mf.copy(shape);
sig2_mf.copy(sig2);
tau_mf.copy (tau );
alpha_mf.copy(alpha);
} // bridge_regression
/* 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;
}
inline bool TRobustRegressionL1PD(
const MATRIX_TYPE& A,
const Eigen::Matrix<REAL, Eigen::Dynamic, 1>& y,
Eigen::Matrix<REAL, Eigen::Dynamic, 1>& xp,
REAL pdtol=1e-3, unsigned pdmaxiter=50)
{
typedef Eigen::Matrix<REAL, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Matrix;
typedef Eigen::Matrix<REAL, Eigen::Dynamic, 1> Vector;
const unsigned M = (unsigned)y.size();
const unsigned N = (unsigned)xp.size();
assert(A.rows() == M && A.cols() == N);
const REAL alpha(0.01);
const REAL beta(0.5);
const REAL mu(10);
Vector x(xp);
Vector Ax(A*x);
Vector tmpM1(y-Ax);
Vector tmpM2(-tmpM1);
Vector tmpM3(tmpM1.cwiseAbs()), tmpM4(M);
Vector u = (tmpM3*REAL(0.95)).array() + tmpM3.maxCoeff()*REAL(0.10);
Vector fu1 = tmpM2-u;
Vector fu2 = tmpM1-u;
Vector lamu1(M), lamu2(M);
for (unsigned i=0; i<M; ++i) {
lamu1(i) = -1.0/fu1(i);
lamu2(i) = -1.0/fu2(i);
}
const MATRIX_TYPE At(A.transpose());
Vector Atv(At*(lamu1-lamu2));
REAL AtvNormSq = Atv.squaredNorm();
Vector rdual((-lamu1-lamu2).array() + REAL(1));
REAL rdualNormSq = rdual.squaredNorm();
Vector w2(M), sig1(M), sig2(M), sigx(M), dx(N), up(N), Atdv(N);
Vector Axp(M), Atvp(M);
Vector &Adx(sigx), &du(w2), &w1p(dx);
Matrix H11p(N,N);
Vector &dlamu1(tmpM3), &dlamu2(tmpM4);
for (unsigned pditer=0; pditer<pdmaxiter; ++pditer) {
// surrogate duality gap
const REAL sdg(-(fu1.dot(lamu1) + fu2.dot(lamu2)));
if (sdg < pdtol)
break;
const REAL tau(mu*2*M/sdg);
const REAL inv_tau = REAL(-1)/tau;
tmpM1 = (-lamu1.cwiseProduct(fu1)).array() + inv_tau;
tmpM2 = (-lamu2.cwiseProduct(fu2)).array() + inv_tau;
const REAL resnorm = sqrt(AtvNormSq + rdualNormSq + tmpM1.squaredNorm() + tmpM2.squaredNorm());
for (unsigned i=0; i<M; ++i) {
REAL& tmpM3i = tmpM3(i);
tmpM3i = inv_tau/fu1(i);
REAL& tmpM4i = tmpM4(i);
tmpM4i = inv_tau/fu2(i);
w2(i) = tmpM3i + tmpM4i - REAL(1);
}
tmpM1 = lamu1.cwiseQuotient(fu1);
tmpM2 = lamu2.cwiseQuotient(fu2);
sig1 = -tmpM1 - tmpM2;
sig2 = tmpM1 - tmpM2;
sigx = sig1 - sig2.cwiseAbs2().cwiseQuotient(sig1);
H11p = At*(Eigen::DiagonalMatrix<REAL,Eigen::Dynamic>(sigx)*A);
w1p = At*(tmpM4 - tmpM3 - (sig2.cwiseQuotient(sig1).cwiseProduct(w2)));
// optimized solver as A is positive definite and symmetric
dx = H11p.ldlt().solve(w1p);
Adx = A*dx;
du = (w2 - sig2.cwiseProduct(Adx)).cwiseQuotient(sig1);
dlamu1 = -tmpM1.cwiseProduct(Adx-du) - lamu1 + tmpM3;
dlamu2 = tmpM2.cwiseProduct(Adx+du) - lamu2 + tmpM4;
Atdv = At*(dlamu1-dlamu2);
// make sure that the step is feasible: keeps lamu1,lamu2 > 0, fu1,fu2 < 0
REAL s(1);
for (unsigned i=0; i<M; ++i) {
REAL& dlamu1i = dlamu1(i);
if (dlamu1i < 0) {
const REAL tmp = -lamu1(i)/dlamu1i;
if (s > tmp)
s = tmp;
}
REAL& dlamu2i = dlamu2(i);
if (dlamu2i < 0) {
const REAL tmp = -lamu2(i)/dlamu2i;
if (s > tmp)
s = tmp;
}
}
for (unsigned i=0; i<M; ++i) {
REAL& Adxi = Adx(i);
REAL& dui = du(i);
REAL Adx_du = Adxi-dui;
if (Adx_du > 0) {
const REAL tmp = -fu1(i)/Adx_du;
if (s > tmp)
s = tmp;
}
Adx_du = -Adxi-dui;
if (Adx_du > 0) {
const REAL tmp = -fu2(i)/Adx_du;
if (s > tmp)
s = tmp;
}
}
s *= REAL(0.99);
// backtrack
lamu1 += s*dlamu1; lamu2 += s*dlamu2;
rdual = (-lamu1-lamu2).array() + REAL(1);
rdualNormSq = rdual.squaredNorm();
bool suffdec = false;
unsigned backiter = 0;
do {
xp = x + s*dx; up = u + s*du;
Axp = Ax + s*Adx; Atvp = Atv + s*Atdv;
fu1 = Axp - y - up; fu2 = -Axp + y - up;
AtvNormSq = Atvp.squaredNorm();
tmpM1 = (-lamu1.cwiseProduct(fu1)).array() + inv_tau;
tmpM2 = (-lamu2.cwiseProduct(fu2)).array() + inv_tau;
const REAL newresnorm = sqrt(AtvNormSq + rdualNormSq + tmpM1.squaredNorm() + tmpM2.squaredNorm());
suffdec = (newresnorm <= (REAL(1)-alpha*s)*resnorm);
s = beta*s;
if (++backiter > 32) {
//("error: stuck backtracking, returning last iterate"); // see Section 4 of notes for more information
xp.swap(x);
return false;
}
} while (!suffdec);
// next iteration
x.swap(xp); u.swap(up);
Ax.swap(Axp); Atv.swap(Atvp);
}
return true;
}
/** 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;
}
