static void mPower (double *A, int eA, double *V, int *eV, int m, int n) { double *B; int eB, i; if (n == 1) { for (i = 0; i < m * m; i++) V[i] = A[i]; *eV = eA; return; } mPower (A, eA, V, eV, m, n / 2); B = (double *) malloc ((m * m) * sizeof (double)); mMultiply (V, V, B, m); eB = 2 * (*eV); if (B[(m / 2) * m + (m / 2)] > NORM) renormalize (B, m, &eB); if (n % 2 == 0) { for (i = 0; i < m * m; i++) V[i] = B[i]; *eV = eB; } else { mMultiply (A, B, V, m); *eV = eA + eB; } if (V[(m / 2) * m + (m / 2)] > NORM) renormalize (V, m, eV); free (B); }
bool Application::perturb(const TigrString &ngram) { throw "OBSOLETE"; // Choose 1 state in each HMM to perturb int state1=RandomNumber(numStates1); int state2=RandomNumber(numStates2); // Get the current emission probabilities for this ngram int symbol=hoa->lookup(ngram); double p1=hmm1->getEmissionProb(state1,symbol); double p2=hmm2->getEmissionProb(state2,symbol); if(p1==0 || p2==0) return false; // Choose direction & size of perturbation const double DELTA=0.1; double delta=DELTA; if(p1<p2) //if(Random0to1()<0.5) delta=-delta; // Install new emission probabilities //hmm1->setEmissionProb(state1,symbol,p1+delta); //hmm2->setEmissionProb(state2,symbol,p2+delta); // Re-normalize to restore sum-to-one constraints renormalize(*hmm1,state1,ngram,symbol,p1+delta); renormalize(*hmm2,state2,ngram,symbol,p2+delta); return true; }
qdouble qdadd(qdouble a, qdouble b) { double x[8]; int i=0,j=0,k; daccres tmp; unqdouble us; for (k=0;k<5;k++) us.v[k] = 0.; for (k=0;k<8;k++) { // merge - sort if (i>3) { x[k] = b.v[j]; j++; } else if (j>3) { x[k] = a.v[i]; i++; } else if (fabs(a.v[i])>=fabs(b.v[j])) { x[k] = a.v[i]; i++; } else { x[k] = b.v[j]; j++; } } // Rprintf("%g %g %g %g %g %g %g %g\n",x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]); double s=0., u=0., v=0.; k = 0; i = 0; while ((k<4)&&(i<8)) { tmp = doubleacc(u,v,x[i]); // Rprintf("- i=%d, k=%d, u=%f, v=%f, x[i]=%f\n",i,k,u,v,x[i]); // Rprintf("+ i=%d, k=%d, s=%f, u=%f, v[i]=%f\n",i,k,tmp.s,tmp.u,tmp.v); s = tmp.s; u = tmp.u; v = tmp.v; if (s!=0.) { // Rprintf(" i=%d, k=%d, v[k]=%f\n",i,k,s); us.v[k] = s; k++; } i++; } if (k<3) us.v[k+1] = v; if (k<4) us.v[k] = u; // Rprintf("%g %g %g %g %g\n",us.v[0],us.v[1],us.v[2],us.v[3],us.v[4]); return(renormalize(us)); }
qdouble qdmult (qdouble a, qdouble b) { unqdouble us; volatile flerr tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9; volatile tsares tmpA,tmpB; volatile flerr tmpC; tmp0 = twoprod(a.v[0],b.v[0]); us.v[0] = tmp0.r; tmp1 = twoprod(a.v[0],b.v[1]); tmp2 = twoprod(a.v[1],b.v[0]); tmpA = threesumsa(tmp0.e,tmp1.r,tmp2.r); us.v[1] = tmpA.v[0]; tmp3 = twoprod(a.v[0],b.v[2]); tmp4 = twoprod(a.v[1],b.v[1]); tmp5 = twoprod(a.v[2],b.v[0]); tmpB = sixthreesum(tmpA.v[1],tmp1.e,tmp2.e,tmp3.r,tmp4.r,tmp5.r); us.v[2] = tmpB.v[0]; tmp6 = twoprod(a.v[0],b.v[3]); tmp7 = twoprod(a.v[1],b.v[2]); tmp8 = twoprod(a.v[2],b.v[1]); tmp9 = twoprod(a.v[3],b.v[0]); tmpC = ninetwosum(tmpA.v[2],tmpB.v[1],tmp3.e,tmp4.e,tmp5.e, tmp6.r,tmp7.r,tmp8.r,tmp9.r); us.v[3] = tmpC.r; us.v[4] = tmpB.v[2] + tmpC.e + tmp6.e + tmp7.e + tmp8.e + tmp9.e + a.v[1]*b.v[3] + a.v[2]*b.v[2] + a.v[3]*b.v[1]; return(renormalize(us)); }
SEXP RENORM1 (SEXP QD) { SEXP Res; PROTECT (Res=allocVector(REALSXP,4)); double *res = REAL(Res); qdouble tmp; unqdouble qd1; for (int i=0;i<4;i++) qd1.v[i] = REAL(QD)[i]; qd1.v[4] = 0.0; tmp = renormalize(qd1); for (int i=0;i<4;i++) res[i] = tmp.v[i]; UNPROTECT(1); return(Res); }
qdouble qdplusd(qdouble a, double b) { unqdouble us; flerr tmp; tmp = twosum(a.v[0],b); us.v[0] = tmp.r; tmp = twosum(a.v[1],tmp.e); us.v[1] = tmp.r; tmp = twosum(a.v[2],tmp.e); us.v[2] = tmp.r; tmp = twosum(a.v[3],tmp.e); us.v[3] = tmp.r; us.v[4] = tmp.e; // Rprintf(" sum of %g + %g + %g + %g and %g\n",a.v[0],a.v[1],a.v[2],a.v[3],b); return(renormalize(us)); }
qdouble qdtimesd (qdouble a, double b) { unqdouble us; volatile flerr tmp1, tmp2, tmp3; tmp1 = twoprod(a.v[0],b); tmp2 = twoprod(a.v[1],b); tmp3 = twoprod(a.v[2],b); us.v[0] = tmp1.r; tmp1 = twosum(tmp2.r,tmp1.e); us.v[1] = tmp1.r; volatile tsares tmp4 = threesumsa(tmp3.r,tmp2.e,tmp1.e); us.v[2] = tmp4.v[0]; volatile tsbres tmp5 = threesumsb(a.v[3]*b,tmp3.e,tmp4.v[1]); us.v[3] = tmp5.v[0]; us.v[4] = tmp5.v[1]+tmp4.v[2]; return(renormalize(us)); }
qdouble qddiv (qdouble a, qdouble b) { volatile double q0, q1, q2, q3, q4; unqdouble us; volatile qdouble r; q0 = a.v[0] / b.v[0]; r = qdadd(a,qdtimesd(b,-q0)); q1 = r.v[0] / b.v[0]; r = qdadd(r,qdtimesd(b,-q1)); q2 = r.v[0] / b.v[0]; r = qdadd(r,qdtimesd(b,-q2)); q3 = r.v[0] / b.v[0]; r = qdadd(r,qdtimesd(b,-q3)); q4 = r.v[0] / b.v[0]; us.v[0] = q0; us.v[1] = q1; us.v[2] = q2; us.v[3] = q3; us.v[4] = q4; return(renormalize(us)); }
qdouble qdadd2 (qdouble a, qdouble b) { unqdouble us; flerr tmp1, tmp2, tmp3, tmp4; tsares tmpA; tsbres tmpB; tmp1 = twosum(a.v[0],b.v[0]); us.v[0] = tmp1.r; tmp2 = twosum(a.v[1],b.v[1]); tmp1 = twosum(tmp2.r,tmp1.e); us.v[1] = tmp1.r; tmp3 = twosum(a.v[2],b.v[2]); tmpA = threesumsa(tmp3.r,tmp1.e,tmp2.e); us.v[2] = tmpA.v[0]; tmp4 = twosum(a.v[3],b.v[3]); tmpB = threesumsb(tmp4.r,tmp3.e,tmpA.v[1]); us.v[3] = tmpB.v[0]; us.v[4] = tmpB.v[1]+tmpA.v[2]+tmp4.e; return(renormalize(us)); }
/********************* * python interface * *********************/ static PyObject* eeint(PyObject* self, PyObject* args){ /*** input variables ***/ /* dictionary */ PyObject *in_dict; PyObject *dictList; PyObject *dictList_fast; PyObject *pyStr; PyObject *item; /* numpy array */ PyArrayObject *in_array1, *in_array2; NpyIter *in_iter; NpyIter_IterNextFunc *in_iternext; /* C data type for input */ int Ngo, Nao; int N, itr; /* basis function variables */ double **in_ptr; // address to numpy pointer double *center; // gaussian center double *cef; // contraction coefficients int *ng; // number of gaussians per AO double *exp; // gaussian exponents int *lm_xyz; // angular momentum /* python output variables */ PyObject *py_out; PyObject *py_out2; double *data, *overlap; double element; int i, j, k, l; int s, t, u, v, w; int mat_dim[4]; /* parse numpy array and two integers as argument */ if (!PyArg_ParseTuple(args, "OO!O!", &in_dict, &PyArray_Type, &in_array1, &PyArray_Type, &in_array2 )) return NULL; if(in_array1 == NULL) return NULL; /*********************** * Construct input data * ***********************/ /*** access dict_list data ***/ /* exponents */ pyStr = PyString_FromString("exponents"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); Ngo = PySequence_Size(dictList); exp = (double*) malloc(Ngo * sizeof(double)); for(i=0;i<Ngo;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); exp[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /* coefficients */ pyStr = PyString_FromString("coefficients"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); cef = (double*) malloc(Ngo * sizeof(double)); for(i=0;i<Ngo;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); cef[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /* number of gaussians per shell */ pyStr = PyString_FromString("n_gaussians"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); Nao = PySequence_Size(dictList); ng = (int*) malloc(Nao * sizeof(int)); for(i=0;i<Nao;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); ng[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /*** end of dict_list data ***/ /*** create the iterators, necessary to access numpy array ***/ /* center */ in_iter = NpyIter_New(in_array1, NPY_ITER_READONLY, NPY_KEEPORDER, NPY_NO_CASTING, NULL); if (in_iter == NULL) goto fail; in_iternext = NpyIter_GetIterNext(in_iter, NULL); if (in_iternext == NULL){ NpyIter_Deallocate(in_iter); goto fail; } /* interator pointer to actual numpy data */ in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter); center = (double*) malloc(3 * Nao * sizeof(double)); itr=0; do { center[itr++] = **in_ptr; } while(in_iternext(in_iter)); NpyIter_Deallocate(in_iter); /* lm_xyz */ in_iter = NpyIter_New(in_array2, NPY_ITER_READONLY, NPY_KEEPORDER, NPY_NO_CASTING, NULL); if (in_iter == NULL) goto fail; in_iternext = NpyIter_GetIterNext(in_iter, NULL); if (in_iternext == NULL){ NpyIter_Deallocate(in_iter); goto fail; } /* interator pointer to actual numpy data */ int **in_ptr2 = (int **) NpyIter_GetDataPtrArray(in_iter); lm_xyz = (int*) malloc(3 * Nao * sizeof(int)); itr=0; do { lm_xyz[itr++] = **in_ptr2; } while(in_iternext(in_iter)); NpyIter_Deallocate(in_iter); /*** end of numpy input data ***/ /***** end of input data construction *****/ /******************* * construct output * *******************/ for(i=0;i<4;i++) mat_dim[i] = Nao; py_out = (PyArrayObject*) PyArray_FromDims(4, mat_dim, NPY_DOUBLE); data = pyvector_to_Carrayptrs(py_out); /* renormalization */ renormalize(center, exp, cef, ng, lm_xyz, Nao); /* orthogonalize */ // no effect at the moment, for debug purpose //py_out2 = (PyArrayObject*) // PyArray_FromDims(2, mat_dim, NPY_DOUBLE); //overlap = pyvector_to_Carrayptrs(py_out2); //orthogonalize(overlap, center, exp, cef, ng, lm_xyz, Nao); #pragma omp parallel private(i, j, k, l, s, t, u, v, w)\ shared(data) { #pragma omp for schedule(dynamic) for(i=0;i<Nao;i++){ for(j=i;j<Nao;j++){ for(k=0;k<Nao;k++){ for(l=k;l<Nao;l++){ if(l+k >= i+j){ s = l + k*Nao + j*Nao*Nao + i*Nao*Nao*Nao; element = eeMatrix(center, exp, cef, ng, lm_xyz, Nao, i, j, k, l); data[s] = element; // symmetry for (ij|kl)=(ij|lk)=(ji|kl)=(ji|lk) t = k + l*Nao + j*Nao*Nao + i*Nao*Nao*Nao; //(ij|lk) u = l + k*Nao + i*Nao*Nao + j*Nao*Nao*Nao; //(ji|kl) v = k + l*Nao + i*Nao*Nao + j*Nao*Nao*Nao; //(ji|lk) data[t] = data[s]; data[u] = data[s]; data[v] = data[s]; // symmetry for (ij|kl)=(kl|ij)=(kl|ji)=(lk|ij)=(lk|ji) t = j + i*Nao + l*Nao*Nao + k*Nao*Nao*Nao; //(kl|ij) u = i + j*Nao + l*Nao*Nao + k*Nao*Nao*Nao; //(kl|ji) v = j + i*Nao + k*Nao*Nao + l*Nao*Nao*Nao; //(lk|ij) w = i + j*Nao + k*Nao*Nao + l*Nao*Nao*Nao; //(lk|ji) data[t] = data[s]; data[u] = data[s]; data[v] = data[s]; data[w] = data[s]; } } } } } } // end of omp loop /********************************* * clean up and return the result * *********************************/ free(exp); free(cef); free(ng); free(center); free(lm_xyz); //free(overlap); Py_INCREF(py_out); return Py_BuildValue("O", py_out); /* in case bad things happen */ fail: Py_XDECREF(py_out); return NULL; } // end of eeint function
// examines weights for filtering failure // computes log likelihood and effective sample size // computes (if desired) prediction mean, prediction variance, filtering mean. // it is assumed that ncol(x) == ncol(params). // weights are used in filtering mean computation. // if length(weights) == 1, an unweighted average is computed. // returns all of the above in a named list SEXP pfilter2_computations (SEXP x, SEXP params, SEXP Np, SEXP rw, SEXP rw_sd, SEXP predmean, SEXP predvar, SEXP filtmean, SEXP onepar, SEXP weights, SEXP tol) { int nprotect = 0; SEXP pm = R_NilValue, pv = R_NilValue, fm = R_NilValue; SEXP rw_names, ess, fail, loglik; SEXP newstates = R_NilValue, newparams = R_NilValue; SEXP retval, retvalnames; double *xpm = 0, *xpv = 0, *xfm = 0, *xw = 0, *xx = 0, *xp = 0, *xpw=0; int *xpa=0; SEXP dimX, dimP, newdim, Xnames, Pnames, pindex; SEXP pw=R_NilValue,pa=R_NilValue, psample=R_NilValue; int *dim, *pidx, lv, np; int nvars, npars = 0, nrw = 0, nreps, offset, nlost; int do_rw, do_pm, do_pv, do_fm, do_par_resamp, all_fail = 0; double sum, sumsq, vsq, ws, w, toler; int j, k; PROTECT(dimX = GET_DIM(x)); nprotect++; dim = INTEGER(dimX); nvars = dim[0]; nreps = dim[1]; xx = REAL(x); PROTECT(Xnames = GET_ROWNAMES(GET_DIMNAMES(x))); nprotect++; PROTECT(dimP = GET_DIM(params)); nprotect++; dim = INTEGER(dimP); npars = dim[0]; if (nreps != dim[1]) error("'states' and 'params' do not agree in second dimension"); PROTECT(Pnames = GET_ROWNAMES(GET_DIMNAMES(params))); nprotect++; np = INTEGER(AS_INTEGER(Np))[0]; // number of particles to resample PROTECT(rw_names = GET_NAMES(rw_sd)); nprotect++; // names of parameters undergoing random walk do_rw = *(LOGICAL(AS_LOGICAL(rw))); // do random walk in parameters? do_pm = *(LOGICAL(AS_LOGICAL(predmean))); // calculate prediction means? do_pv = *(LOGICAL(AS_LOGICAL(predvar))); // calculate prediction variances? do_fm = *(LOGICAL(AS_LOGICAL(filtmean))); // calculate filtering means? do_par_resamp = *(LOGICAL(AS_LOGICAL(onepar))); // are all cols of 'params' the same? do_par_resamp = !do_par_resamp || do_rw || (np != nreps); // should we do parameter resampling? PROTECT(ess = NEW_NUMERIC(1)); nprotect++; // effective sample size PROTECT(loglik = NEW_NUMERIC(1)); nprotect++; // log likelihood PROTECT(fail = NEW_LOGICAL(1)); nprotect++; // particle failure? xw = REAL(weights); toler = *(REAL(tol)); // failure tolerance // check the weights and compute sum and sum of squares for (k = 0, w = 0, ws = 0, nlost = 0; k < nreps; k++) { if (xw[k] >= 0) { w += xw[k]; ws += xw[k]*xw[k]; } else { // this particle is lost xw[k] = 0; nlost++; } } if (nlost >= nreps) all_fail = 1; // all particles are lost if (all_fail) { *(REAL(loglik)) = log(toler); // minimum log-likelihood *(REAL(ess)) = 0; // zero effective sample size } else { *(REAL(loglik)) = log(w/((double) nreps)); // mean of weights is likelihood *(REAL(ess)) = w*w/ws; // effective sample size } *(LOGICAL(fail)) = all_fail; if (do_rw) { // indices of parameters undergoing random walk PROTECT(pindex = matchnames(Pnames,rw_names,"parameters")); nprotect++; xp = REAL(params); pidx = INTEGER(pindex); nrw = LENGTH(rw_names); lv = nvars+nrw; } else { pidx = NULL; lv = nvars; } if (do_pm || do_pv) { PROTECT(pm = NEW_NUMERIC(lv)); nprotect++; xpm = REAL(pm); } if (do_pv) { PROTECT(pv = NEW_NUMERIC(lv)); nprotect++; xpv = REAL(pv); } if (do_fm) { if (do_rw) { PROTECT(fm = NEW_NUMERIC(nvars+npars)); nprotect++; } else { PROTECT(fm = NEW_NUMERIC(nvars)); nprotect++; } xfm = REAL(fm); } PROTECT(pa = NEW_INTEGER(np)); nprotect++; xpa = INTEGER(pa); for (j = 0; j < nvars; j++) { // state variables // compute prediction mean if (do_pm || do_pv) { for (k = 0, sum = 0; k < nreps; k++) sum += xx[j+k*nvars]; sum /= ((double) nreps); xpm[j] = sum; } // compute prediction variance if (do_pv) { for (k = 0, sumsq = 0; k < nreps; k++) { vsq = xx[j+k*nvars]-sum; sumsq += vsq*vsq; } xpv[j] = sumsq / ((double) (nreps - 1)); } // compute filter mean if (do_fm) { if (all_fail) { // unweighted average for (k = 0, ws = 0; k < nreps; k++) ws += xx[j+k*nvars]; xfm[j] = ws/((double) nreps); } else { // weighted average for (k = 0, ws = 0; k < nreps; k++) ws += xx[j+k*nvars]*xw[k]; xfm[j] = ws/w; } } } // compute means and variances for parameters (if needed) if (do_rw) { for (j = 0; j < nrw; j++) { offset = pidx[j]; // position of the parameter if (do_pm || do_pv) { for (k = 0, sum = 0; k < nreps; k++) sum += xp[offset+k*npars]; sum /= ((double) nreps); xpm[nvars+j] = sum; } if (do_pv) { for (k = 0, sumsq = 0; k < nreps; k++) { vsq = xp[offset+k*npars]-sum; sumsq += vsq*vsq; } xpv[nvars+j] = sumsq / ((double) (nreps - 1)); } } if (do_fm) { for (j = 0; j < npars; j++) { if (all_fail) { // unweighted average for (k = 0, ws = 0; k < nreps; k++) ws += xp[j+k*npars]; xfm[nvars+j] = ws/((double) nreps); } else { // weighted average for (k = 0, ws = 0; k < nreps; k++) ws += xp[j+k*npars]*xw[k]; xfm[nvars+j] = ws/w; } } } } GetRNGstate(); if (!all_fail) { // resample the particles unless we have filtering failure int xdim[2]; //int sample[np]; double *ss = 0, *st = 0, *ps = 0, *pt = 0; // create storage for new states xdim[0] = nvars; xdim[1] = np; PROTECT(newstates = makearray(2,xdim)); nprotect++; setrownames(newstates,Xnames,2); ss = REAL(x); st = REAL(newstates); // create storage for new parameters if (do_par_resamp) { xdim[0] = npars; xdim[1] = np; PROTECT(newparams = makearray(2,xdim)); nprotect++; setrownames(newparams,Pnames,2); ps = REAL(params); pt = REAL(newparams); } PROTECT(pw = NEW_NUMERIC(nreps)); nprotect++; xpw = REAL(pw); for (k = 0; k < nreps; k++) xpw[k]=REAL(weights)[k]; nosort_resamp(nreps,REAL(weights),np,xpa,0); for (k = 0; k < np; k++) { // copy the particles for (j = 0, xx = ss+nvars*xpa[k]; j < nvars; j++, st++, xx++) *st = *xx; if (do_par_resamp) { for (j = 0, xp = ps+npars*xpa[k]; j < npars; j++, pt++, xp++){ *pt = *xp; } } } } else { // don't resample: just drop 3rd dimension in x prior to return PROTECT(newdim = NEW_INTEGER(2)); nprotect++; dim = INTEGER(newdim); dim[0] = nvars; dim[1] = nreps; SET_DIM(x,newdim); setrownames(x,Xnames,2); } if (do_rw) { // if random walk, adjust prediction variance and move particles xx = REAL(rw_sd); xp = (all_fail || !do_par_resamp) ? REAL(params) : REAL(newparams); nreps = (all_fail) ? nreps : np; for (j = 0; j < nrw; j++) { offset = pidx[j]; vsq = xx[j]; if (do_pv) { xpv[nvars+j] += vsq*vsq; } for (k = 0; k < nreps; k++) xp[offset+k*npars] += rnorm(0,vsq); } } renormalize(xpw,nreps,0); PutRNGstate(); PROTECT(retval = NEW_LIST(10)); nprotect++; PROTECT(retvalnames = NEW_CHARACTER(10)); nprotect++; SET_STRING_ELT(retvalnames,0,mkChar("fail")); SET_STRING_ELT(retvalnames,1,mkChar("loglik")); SET_STRING_ELT(retvalnames,2,mkChar("ess")); SET_STRING_ELT(retvalnames,3,mkChar("states")); SET_STRING_ELT(retvalnames,4,mkChar("params")); SET_STRING_ELT(retvalnames,5,mkChar("pm")); SET_STRING_ELT(retvalnames,6,mkChar("pv")); SET_STRING_ELT(retvalnames,7,mkChar("fm")); SET_STRING_ELT(retvalnames,8,mkChar("weight")); SET_STRING_ELT(retvalnames,9,mkChar("pa")); SET_NAMES(retval,retvalnames); SET_ELEMENT(retval,0,fail); SET_ELEMENT(retval,1,loglik); SET_ELEMENT(retval,2,ess); if (all_fail) { SET_ELEMENT(retval,3,x); } else { SET_ELEMENT(retval,3,newstates); } if (all_fail || !do_par_resamp) { SET_ELEMENT(retval,4,params); } else { SET_ELEMENT(retval,4,newparams); } if (do_pm) { SET_ELEMENT(retval,5,pm); } if (do_pv) { SET_ELEMENT(retval,6,pv); } if (do_fm) { SET_ELEMENT(retval,7,fm); } SET_ELEMENT(retval,8,pw); SET_ELEMENT(retval,9,pa); UNPROTECT(nprotect); return(retval); }
double thermo_sa(double temp_init, double temp_end, double temp_sig, double initstate, double bm_sigma, double k, FILE * log) { double energy, energy_new, energy_delta, energy_variation; int *path; double temp, temp_old; double prob; double rot_old, best_rot; double entropy_variation; double energy_best; gsl_rng *acpt_rng; unsigned long time = 0; double BM; /* * Initialize the random number generators. */ _bm_rng = gsl_rng_alloc(gsl_rng_taus); acpt_rng = gsl_rng_alloc(gsl_rng_taus); temp = temp_init; rotation = initstate; /* * Compute the first path. */ path = renormalize(); energy = route_length(path, tsp->dimension); free(path); energy_best = energy; entropy_variation = 0; energy_variation = 0; /* * Print the log headers. */ if (log != NULL) (void) fprintf(log, "time T E_n E_d E_v E_b S_v rb r rv bm\n"); do { temp_old = temp; rot_old = rotation; if (log != NULL) (void) fprintf(log, "%lu ", time); BM = neighbour_rot(temp, temp_end, temp_init, bm_sigma); if(fpclassify(rotation) == FP_NAN) errx(EX_DATAERR, "Rotation can not be NaN"); path = renormalize(); energy_new = route_length(path, tsp->dimension); free(path); energy_delta = energy_new - energy; prob = exp(-energy_delta / temp); if (log != NULL) (void)fprintf(log, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n", temp, energy_new, energy_delta, energy_variation, energy_best, entropy_variation, best_rot, rotation, (rotation - rot_old), BM); if (gsl_rng_uniform(acpt_rng) < prob) { if (energy_best > energy) { energy_best = energy; best_rot = rot_old; } energy = energy_new; energy_variation += energy_delta; } else rotation = rot_old; if (energy_delta > 0) entropy_variation -= energy_delta / temp; if ((energy_variation >= 0) || fabs(entropy_variation) < 0.000001) temp = temp_init; else { temp = k * (energy_variation / entropy_variation); //rotation = best_rot; } time++; } while ((temp > temp_end) || (fabs(temp - temp_old) > temp_sig)); gsl_rng_free(acpt_rng); gsl_rng_free(_bm_rng); return energy_best; }
/********************* * python interface * *********************/ static PyObject* eekernel(PyObject* self, PyObject* args){ /*** input variables ***/ /* dictionary */ PyObject *in_dict; PyObject *dictList; PyObject *dictList_fast; PyObject *pyStr; PyObject *item; /* list */ PyObject *in_list; PyObject *list_fast; /* numpy array */ PyArrayObject *in_array1, *in_array2, *in_array3; NpyIter *in_iter; NpyIter_IterNextFunc *in_iternext; /* C data type for input */ int Ngo, Nao; int N, itr; double *Z; double *R; /* basis function variables */ double **in_ptr; // address to numpy pointer double *center; // gaussian center double *cef; // contraction coefficients int *ng; // number of gaussians per AO double *exp; // gaussian exponents int *lm_xyz; // angular momentum /* python output variables */ PyObject *py_out; PyObject *py_out2; double *data, *overlap; int i, j, k; int mat_dim[3]; /* parse numpy array and two integers as argument */ if (!PyArg_ParseTuple(args, "OO!O!O!O", &in_dict, &PyArray_Type, &in_array1, &PyArray_Type, &in_array2, &PyArray_Type, &in_array3, &in_list )) return NULL; if(in_array1 == NULL) return NULL; /*********************** * Construct input data * ***********************/ /*** access dict_list data ***/ /* exponents */ pyStr = PyString_FromString("exponents"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); Ngo = PySequence_Size(dictList); exp = (double*) malloc(Ngo * sizeof(double)); for(i=0;i<Ngo;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); exp[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /* coefficients */ pyStr = PyString_FromString("coefficients"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); cef = (double*) malloc(Ngo * sizeof(double)); for(i=0;i<Ngo;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); cef[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /* number of gaussians per shell */ pyStr = PyString_FromString("n_gaussians"); dictList = PyDict_GetItem(in_dict, pyStr); dictList_fast = PySequence_Fast( dictList, "expected a sequence"); Nao = PySequence_Size(dictList); ng = (int*) malloc(Nao * sizeof(int)); for(i=0;i<Nao;i++){ item = PySequence_Fast_GET_ITEM(dictList_fast, i); ng[i] = PyFloat_AsDouble(item); } Py_DECREF(dictList_fast); /*** end of dict_list data ***/ /*** access python list data ***/ list_fast = PySequence_Fast(in_list, "expected a sequence"); N = PySequence_Size(in_list); Z = (double*) malloc(N * sizeof(double)); for(i=0;i<N;i++){ item = PySequence_Fast_GET_ITEM(list_fast, i); Z[i] = PyFloat_AsDouble(item); } Py_DECREF(list_fast); /*** end of list input data ***/ /*** create the iterators, necessary to access numpy array ***/ /* center */ in_iter = NpyIter_New(in_array1, NPY_ITER_READONLY, NPY_KEEPORDER, NPY_NO_CASTING, NULL); if (in_iter == NULL) goto fail; in_iternext = NpyIter_GetIterNext(in_iter, NULL); if (in_iternext == NULL){ NpyIter_Deallocate(in_iter); goto fail; } /* interator pointer to actual numpy data */ in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter); center = (double*) malloc(3 * Nao * sizeof(double)); itr=0; do { center[itr++] = **in_ptr; } while(in_iternext(in_iter)); NpyIter_Deallocate(in_iter); /* lm_xyz */ in_iter = NpyIter_New(in_array2, NPY_ITER_READONLY, NPY_KEEPORDER, NPY_NO_CASTING, NULL); if (in_iter == NULL) goto fail; in_iternext = NpyIter_GetIterNext(in_iter, NULL); if (in_iternext == NULL){ NpyIter_Deallocate(in_iter); goto fail; } /* interator pointer to actual numpy data */ int **in_ptr2 = (int **) NpyIter_GetDataPtrArray(in_iter); lm_xyz = (int*) malloc(3 * Nao * sizeof(int)); itr=0; do { lm_xyz[itr++] = **in_ptr2; } while(in_iternext(in_iter)); NpyIter_Deallocate(in_iter); /* R */ in_iter = NpyIter_New(in_array3, NPY_ITER_READONLY, NPY_KEEPORDER, NPY_NO_CASTING, NULL); if (in_iter == NULL) goto fail; in_iternext = NpyIter_GetIterNext(in_iter, NULL); if (in_iternext == NULL){ NpyIter_Deallocate(in_iter); goto fail; } /* interator pointer to actual numpy data */ in_ptr = (double **) NpyIter_GetDataPtrArray(in_iter); R = (double*) malloc(3 * N * sizeof(double)); itr=0; do { R[itr++] = **in_ptr; } while(in_iternext(in_iter)); NpyIter_Deallocate(in_iter); /*** end of numpy input data ***/ /***** end of input data construction *****/ /******************* * construct output * *******************/ mat_dim[0] = Nao; mat_dim[1] = Nao; mat_dim[2] = N; py_out = (PyArrayObject*) PyArray_FromDims(3, mat_dim, NPY_DOUBLE); data = pyvector_to_Carrayptrs(py_out); /* renormalization */ renormalize(center, exp, cef, ng, lm_xyz, Nao); /* orthogonalize */ // no effect at the moment, for debug purpose //py_out2 = (PyArrayObject*) // PyArray_FromDims(2, mat_dim, NPY_DOUBLE); //overlap = pyvector_to_Carrayptrs(py_out2); //orthogonalize(overlap, center, exp, cef, ng, lm_xyz, Nao); #pragma omp parallel private(i, j, k) shared(data) { #pragma omp for schedule(dynamic) for(i=0;i<Nao;i++){ for(j=i;j<Nao;j++){ eeKernel(R, Z, center, exp, cef, &data[Nao*N*i + N*j], ng, lm_xyz, Nao, N, i, j); if(j!=i){ for(k=0;k<N;k++) data[i*N+j*Nao*N + k] = data[j*N+i*Nao*N + k]; } } } } // end of omp loop /********************************* * clean up and return the result * *********************************/ free(exp); free(cef); free(ng); free(center); free(R); free(Z); free(overlap); Py_INCREF(py_out); return Py_BuildValue("O", py_out); /* in case bad things happen */ fail: Py_XDECREF(py_out); return NULL; }
void HMM::trainGibbsFromFile(char* inputFile) { double **emit_count; double **trans_count; double *state_count; double *sequence_count; double *init_count; double *obs_count; emit_count = createMatrix(_numStates, _numObs); trans_count = createMatrix(_maxState, _numStates); state_count = new double[_numStates]; zeroArray(state_count, _numStates); obs_count = new double[_numObs]; zeroArray(obs_count, _numObs); sequence_count = new double[_maxState]; zeroArray(sequence_count, _maxState); init_count = new double[_maxState]; zeroArray(init_count, _maxState); ifstream trainFile(inputFile); string line; int count = 0; while (getline(trainFile, line)) { // for every sentence vector<int> words; stringstream ss(line); string buf; while (ss >> buf) { words.push_back(atoi(buf.c_str())); } int len = words.size(); count++; int *stateArray; stateArray = new int[len]; for (int i = 0; i < len; i++) { int origState = (rand() % (_numStates - 1)) + 1; int obs = words[i]; int prev_sequence = 0; int r = 0; stateArray[i] = origState; while ((r < _order) && (i - 1 - r) >= 0) { prev_sequence += stateArray[(i - 1) - r] * int(pow(_numStates, r)); r++; } obs_count[obs]++; state_count[origState]++; if (i == 0) init_count[origState]++; else { trans_count[prev_sequence][origState]++; sequence_count[prev_sequence]++; } emit_count[origState][obs]++; } int sampleN = rand() % len; for (int i = 0; i < sampleN; i++) { int k = rand() % (len - 1); int obs = words[k]; int prev_sequence = 0; int r = 0; // cout << "Compute prev_seq" << endl; while ((r < _order) && (k - 1 - r) >= 0) { prev_sequence += stateArray[(k - 1) - r] * int(pow(_numStates, r)); r++; } // cout << "Done Compute prev_seq" << endl; int origState = stateArray[k]; int nextState = stateArray[k + 1]; int next_sequence = _numStates * (prev_sequence % int(pow(_numStates, _order - 1))) + origState; double *dist = new double[_numStates]; double totalp = 0; for (int state = 0; state < _numStates; state++) { int state_sequence = _numStates * (prev_sequence % int(pow(_numStates, _order - 1))) + state; if (prev_sequence == 0) dist[state] = _pObservation[state][obs] * initial_probability[state] * _pTransition[state_sequence][nextState]; else dist[state] = _pObservation[state][obs] * _pTransition[prev_sequence][state] * _pTransition[state_sequence][nextState]; totalp += dist[state]; } renormalize(dist, _numStates); Distribution d(dist, _numStates); int sample = d.generate_sample(); delete[] dist; // cout << "Update params" << endl; state_count[origState]--; if (k == 0) { init_count[origState]--; init_count[sample]++; } else { trans_count[prev_sequence][origState]--; trans_count[prev_sequence][sample]++; } trans_count[next_sequence][nextState]--; sequence_count[next_sequence]--; emit_count[origState][obs]--; stateArray[k] = sample; next_sequence = _numStates * (prev_sequence % int(pow(_numStates, _order - 1))) + sample; state_count[sample]++; trans_count[next_sequence][nextState]++; sequence_count[next_sequence]++; emit_count[sample][obs]++; // cout << "Done Update params" << endl; } }//end for every sentence trainFile.close(); updateHMM(emit_count, trans_count, state_count, sequence_count, init_count, obs_count); freeMatrix(trans_count, _maxState, _numStates); freeMatrix(emit_count, _numStates, _numObs); delete[] state_count; delete[] obs_count; delete[] sequence_count; }
void RigidBody::rotate(Quaternion rot){ mQ = rot * mQ; renormalize(); }
//------------------------------------------------------------------------------ bool ComplexTimeRungeKuttaFehlberg::stepForward() { cx_vec k1, k2, k3, k4, k5, k6; cx_mat m1, m2, m3, m4, m5, m6; cx_vec A_, A_1; cx_mat C_, C_1; bool accepted = false; // Computing Runge-Kutta weights V->computeNewElements(C); h->computeNewElements(C); k1 = -i*dt*slater->computeRightHandSideComplexTime(A); m1 = -i*dt*orbital->computeRightHandSide(C, A); V->computeNewElements(C + m1/4.0); h->computeNewElements(C + m1/4.0); k2 = -i*dt*slater->computeRightHandSideComplexTime(A + k1/4.0); m2 = -i*dt*orbital->computeRightHandSide(C + m1/4.0, A + k1/4.0); V->computeNewElements(C + 3.0/32*m1 + 9.0/32*m2); h->computeNewElements(C + 3.0/32*m1 + 9.0/32*m2); k3 = -i*dt*slater->computeRightHandSideComplexTime(A + 3.0/32*k1 + 9.0/32*k2); m3 = -i*dt*orbital->computeRightHandSide(C + 3.0/32*m1 + 9.0/32*m2, A + 3.0/32*k1 + 9.0/32*k2); V->computeNewElements(C + 1932.0/2197*m1 - 7200.0/2197*m2 + 7296.0/2197*m3); h->computeNewElements(C + 1932.0/2197*m1 - 7200.0/2197*m2 + 7296.0/2197*m3); k4 = -i*dt*slater->computeRightHandSideComplexTime(A + 1932.0/2197*k1 - 7200.0/2197*k2 + 7296.0/2197*k3); m4 = -i*dt*orbital->computeRightHandSide(C + 1932.0/2197*m1 - 7200.0/2197*m2 + 7296.0/2197*m3, A + 1932.0/2197*k1 - 7200.0/2197*k2 + 7296.0/2197*k3); V->computeNewElements(C + 439.0/216*m1 - 8.0*m2 + 3680.0/513*m3 - 845.0/4104*m4); h->computeNewElements(C + 439.0/216*m1 - 8.0*m2 + 3680.0/513*m3 - 845.0/4104*m4); k5 = -i*dt*slater->computeRightHandSideComplexTime(A + 439.0/216*k1 - 8.0*k2 + 3680.0/513*k3 - 845.0/4104*k4); m5 = -i*dt*orbital->computeRightHandSide(C + 439.0/216*m1 - 8.0*m2 + 3680.0/513*m3 - 845.0/4104*m4, A + 439.0/216*k1 - 8.0*k2 + 3680.0/513*k3 - 845.0/4104*k4); V->computeNewElements(C - 8.0/27*m1 + 2.0*m2 - 3544.0/2565*m3 + 1859.0/4104*m4 - 11.0/40*m5); h->computeNewElements(C - 8.0/27*m1 + 2.0*m2 - 3544.0/2565*m3 + 1859.0/4104*m4 - 11.0/40*m5); k6 = -i*dt*slater->computeRightHandSideComplexTime(A - 8.0/27*k1 + 2.0*k2 - 3544.0/2565*k3 + 1859.0/4104*k4 - 11.0/40*k5); m6 = -i*dt*orbital->computeRightHandSide(C - 8.0/27*m1 + 2.0*m2 - 3544.0/2565*m3 + 1859.0/4104*m4 - 11.0/40*m5, A - 8.0/27*k1 + 2.0*k2 - 3544.0/2565*k3 + 1859.0/4104*k4 - 11.0/40*k5); // Computing new states A_ = A + 16.0/135*k1 + 6656.0/12825*k3 + 28561.0/56430*k4 - 9.0/50*k5 + 2.0/55*k6; A_1 = A + 25.0/216*k1 + 1408.0/2565*k3 + 2197.0/4104*k4 - 1.0/5*k5; C_ = C + 16.0/135*m1 + 6656.0/12825*m3 + 28561.0/56430*m4 - 9.0/50*m5 + 2.0/55*m6; C_1 = C + 25.0/216*m1 + 1408.0/2565*m3 + 2197.0/4104*m4 - 1.0/5*m5; vec R; double maxR; double rTmp; R = 1.0/dt*abs(A_ - A_1); maxR = max(R); for(uint i=0; i<C.n_cols; i++){ R = 1.0/dt*abs(C_.col(i) - C_1.col(i)); rTmp = max(R); if(rTmp > maxR) maxR = rTmp; } double delta = 0.84*pow(epsilon/maxR, 0.25); if(maxR <= epsilon){ C = C_1; A = A_1; t += dt; dt = delta*dt; // Normalizing renormalize(C); A = A/sqrt(cdot(A,A)); accepted = true; }else { dt = delta*dt; step--; } return accepted; }
void HMM::trainGibbsParallel(vector<string> files_list) { int count = files_list.size(); int rank = MPI::COMM_WORLD.Get_rank(); int size = MPI::COMM_WORLD.Get_size(); const int root = 0; int dist = count / size; int start = rank * dist; int end = rank * dist + dist; double **emit_count; double **trans_count; double *state_count; double *sequence_count; double *init_count; double *obs_count; emit_count = createMatrix(_numStates, _numObs); trans_count = createMatrix(_maxState, _numStates); state_count = new double[_numStates]; zeroArray(state_count, _numStates); obs_count = new double[_numObs]; zeroArray(obs_count, _numObs); sequence_count = new double[_maxState]; zeroArray(sequence_count, _maxState); init_count = new double[_maxState]; zeroArray(init_count, _maxState); double **temit_count; double **ttrans_count; double *tstate_count; double *tsequence_count; double *tinit_count; double *tobs_count; temit_count = createMatrix(_numStates, _numObs); ttrans_count = createMatrix(_maxState, _numStates); tstate_count = new double[_numStates]; zeroArray(tstate_count, _numStates); tobs_count = new double[_numObs]; zeroArray(tobs_count, _numObs); tsequence_count = new double[_maxState]; zeroArray(tsequence_count, _maxState); tinit_count = new double[_maxState]; zeroArray(tinit_count, _maxState); for (int i = start; i < end; i++) { const char* inputFile = files_list[i].c_str(); ifstream trainFile(inputFile); string line; while (getline(trainFile, line)) { // for every sentence // Read in training sequence vector<int> words; stringstream ss(line); string buf; while (ss >> buf) { words.push_back(atoi(buf.c_str())); } int len = words.size(); count++; int *stateArray; stateArray = new int[len]; for (int i = 0; i < len; i++) { int origState = (rand() % (_numStates - 1)) + 1; int obs = words[i]; int prev_sequence = 0; int r = 0; stateArray[i] = origState; if (i == 0) init_count[origState]++; else { while ((r < _order) && (i - 1 - r) >= 0) { prev_sequence += stateArray[(i - 1) - r] * int(pow(_numStates, r)); r++; } trans_count[prev_sequence][origState]++; sequence_count[prev_sequence]++; } obs_count[obs]++; state_count[origState]++; emit_count[origState][obs]++; } int sampleN = rand() % len; for (int i = 0; i < sampleN; i++) { int k = rand() % (len - 1); int obs = words[k]; int prev_sequence = 0; int r = 0; // cout << "Compute seq " <<endl; while ((r < _order) && (k - 1 - r) >= 0) { prev_sequence += stateArray[(k - 1) - r] * int(pow(_numStates, r)); r++; } // cout << "Done Compute seq " <<endl; int origState = stateArray[k]; int nextState = stateArray[k + 1]; int next_sequence = _numStates * (prev_sequence % int(pow(_numStates, _order - 1))) + nextState; double *dist = new double[_numStates]; double totalp = 0; for (int state = 0; state < _numStates; state++) { int state_sequence = _numStates * (prev_sequence % int(pow(_numStates, _order - 1))) + state; if (prev_sequence == 0) dist[state] = _pObservation[state][obs] * initial_probability[state] * _pTransition[state_sequence][nextState]; else dist[state] = _pObservation[state][obs] * _pTransition[prev_sequence][state] * _pTransition[state_sequence][nextState]; totalp += dist[state]; } renormalize(dist, _numStates); Distribution d(dist, _numStates); int sample = d.generate_sample(); delete[] dist; if (k == 0) { init_count[origState]--; init_count[sample]++; } else { trans_count[prev_sequence][origState]--; trans_count[prev_sequence][sample]++; } state_count[origState]--; // trans_count[next_sequence][nextState]--; // sequence_count[next_sequence]--; emit_count[origState][obs]--; stateArray[k] = sample; // next_sequence = _numStates*(prev_sequence % int(pow(_numStates, _order-1))) + sample; state_count[sample]++; // trans_count[next_sequence][nextState]++; // sequence_count[next_sequence]++; emit_count[sample][obs]++; // cout << "Done Update parameters" << endl; } }//end for every sentence trainFile.close(); } // for every file //Collect parameters on root for (int state_sequence = 0; state_sequence < _maxState; state_sequence++) { MPI_Reduce(trans_count[state_sequence], ttrans_count[state_sequence], _numStates, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); } MPI_Reduce(sequence_count, tsequence_count, _maxState, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); MPI_Reduce(init_count, tinit_count, _maxState, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); for (int state = 0; state < _numStates; state++) { MPI_Reduce(emit_count[state], temit_count[state], _numObs, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); } MPI_Reduce(state_count, tstate_count, _numStates, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); MPI_Reduce(obs_count, tobs_count, _numObs, MPI_DOUBLE, MPI_SUM, root, MPI_COMM_WORLD); //Send updated parameters too all children for (int state_sequence = 0; state_sequence < _maxState; state_sequence++) { MPI_Bcast(ttrans_count[state_sequence], _numStates, MPI_DOUBLE, root, MPI_COMM_WORLD); } MPI_Bcast(tsequence_count, _maxState, MPI_DOUBLE, root, MPI_COMM_WORLD); MPI_Bcast(tinit_count, _maxState, MPI_DOUBLE, root, MPI_COMM_WORLD); for (int state = 0; state < _numStates; state++) { MPI_Bcast(temit_count[state], _numObs, MPI_DOUBLE, root, MPI_COMM_WORLD); } MPI_Bcast(tstate_count, _numStates, MPI_DOUBLE, root, MPI_COMM_WORLD); MPI_Bcast(tobs_count, _numObs, MPI_DOUBLE, root, MPI_COMM_WORLD); //cout << "Update Step" << endl; updateHMM(temit_count, ttrans_count, tstate_count, tsequence_count, tinit_count, tobs_count); freeMatrix(trans_count, _maxState, _numStates); freeMatrix(emit_count, _numStates, _numObs); delete[] state_count; delete[] sequence_count; delete[] init_count; delete[] obs_count; freeMatrix(temit_count, _numStates, _numObs); freeMatrix(ttrans_count, _maxState, _numStates); delete[] tstate_count; delete[] tsequence_count; delete[] tinit_count; delete[] tobs_count; }