int gauss(dvec& x, dvec& w) {
int n = x.size();
double dist = 1;
double tol = 1e-15;
int iter = 0;
// Use Chebyshev-Gauss nodes and initial guess
initguess(x);
// chebnodes(x);
dvec x0(x);
dvec L(n,0.0);
dvec Lp(n,0.0);
dvec a(n,0.0);
dvec b(n,0.0);
rec_legendre(a,b);
// Iteratively correct nodes with Newton's method
while(dist>tol) {
newton_step(a,b,x,L,Lp);
dist = dist_max(x,x0);
++iter;
x0 = x;
}
// Compute Weights
for(int i=0;i<n;++i){
w[i] = 2.0/((1-x[i]*x[i])*(Lp[i]*Lp[i]));
}
return iter;
}
int main(void)
{
typedef double RealType;
typedef mcpack::utils::GaussPotentialEnergy<RealType> PotEngType;
typedef PotEngType::RealVectorType RealVectorType;
typedef PotEngType::RealMatrixType RealMatrixType;
typedef RealMatrixType::Index IndexType;
typedef mcpack::hamiltonian::GaussKineticEnergy<RealType> KinEngType;
typedef mcpack::hamiltonian::LeapFrog<PotEngType,KinEngType> IntegratorType;
typedef mcpack::utils::RandomVariateGenerator<RealType> RandVarGenType;
typedef mcpack::hamiltonian::HMCProposal<IntegratorType,RandVarGenType> HMCProposalType;
//typedef mcpack::hamiltonian::ClassicHMC<HMCProposalType> HMCType;
typedef mcpack::hamiltonian::MPIInterChainClassicHMC<HMCProposalType> HMCType;
const IndexType N=10;
RealVectorType mu=RealVectorType::Zero(N);
RealMatrixType SigmaInv=RealMatrixType::Identity(N,N);
RealMatrixType MInv=RealMatrixType::Identity(N,N);
RealVectorType q0=RealVectorType::Random(N);
const RealType eps=1;
const IndexType Nsteps=10;
PotEngType G(mu,SigmaInv);
KinEngType K(MInv);
IntegratorType Lp(G,K);
HMCProposalType prop(Lp,eps,Nsteps);
HMCType hmc(prop,q0,12346l);
const IndexType NSamples=1000;
RealMatrixType Samples(NSamples,N);
hmc.Generate(Samples);
std::cout<<"Acceptace Rate= "<<hmc.GetAcceptanceRate()<<std::endl;
return 0;
}
double LVector::apertureFlux(double R_, int maxP) const
{
static boost::shared_ptr<tmv::Vector<double> > fp;
static double R=-1.;
static double psize=-1;
assert(R_>=0.);
if (maxP<0) maxP= getOrder()/2;
if (maxP > getOrder()/2) maxP=getOrder()/2;
if (!fp.get() || R_ != R || maxP>psize) {
fp.reset(new tmv::Vector<double>(maxP));
psize = maxP;
R = R_;
tmv::Vector<double> Lp(maxP+1);
tmv::Vector<double> Qp(maxP+1);
double x = R*R;
double efact = std::exp(-0.5*x);
Lp[0] = Qp[0]=1.;
if (maxP>0) {
Lp[1] = 1. - x;
Qp[1] = -1. - x;
}
for (int p=1; p<maxP; p++) {
Lp[p+1] = ((2*p+1-x)*Lp[p]-p*Lp[p-1])/(p+1);
Qp[p+1] = (-x*Lp[p]-Qp[p]+p*Qp[p-1])/(p+1);
}
for (int p=0; p<=maxP; p++)
(*fp)[p] = 1. - efact*Qp[p]*(p%2==0 ? 1. : -1.);
}
double flux = 0.;
for (int p=0; p<=maxP; p++)
flux += (*_v)[PQIndex(p,p).rIndex()] * (*fp)[p];
return flux;
}
