static gdouble X2(gint n,gint l1,gint l2,gdouble A, gdouble B,gdouble g)
{
gint i,r,l;
gint imin,imax;
gdouble X=0.0;
gdouble fourg=4*g;
l=l1+l2;
imin=n;
if(n%2 == 0)
{
if( l%2==0) imax = l;
else imax = l-1;
}
else
{
if( l%2==0) imax = l-1;
else imax = l;
}
for(i=imin;i<=imax;i+=2)
{
r = (i-n)/2;
X+=m1p(i)*binomial2(i,r)/dpn(fourg,i-r)*f(i,l1,l2,A,B);
}
return X;
}
static gdouble X1(gint n,gint l1,gint l2,gdouble A, gdouble B,gdouble g)
{
gint i,r,l;
gint imin,imax;
gdouble X=0.0;
gdouble fourg=4*g;
l=l1+l2;
imin=n;
if(n%2 == 0)
{
if( l%2==0) imax = l;
else imax = l-1;
}
else
{
if( l%2==0) imax = l-1;
else imax = l;
}
for(i=imin;i<=imax;i+=2)
{
r = (i-n)/2;
/* printf("n=%d i=%d r=%d \n",n,i,r);*/
/* printf("CI2J=%f f=%f \n",binomial2(i,r),f(i,l1,l2,A,B));*/
X+=binomial2(i,r)/dpn(fourg,i-r)*f(i,l1,l2,A,B);
}
/* printf("g=%f X=%f\n",g,X);*/
return X;
}
int main() {
scanf("%d", &t);
while (t--) {
// «i have at least Dices with a Number»
scanf("%d %d\n%d %d %d %d\n",
&totDices, &nFaces,
&djDices, &djNumber,
&wtDices, &wtNumber);
double succProb = 1.0 / nFaces;
double djGuess = binomial2(succProb, djDices, totDices);
double wtGuess = binomial2(succProb, wtDices, totDices);
double answer = (djGuess + wtGuess) / 2.0;
printf("%lf", answer);
} // end while t
return 0;
}
/**
@brief computes jk fock matrix operator
@param basis basis handle
@param D density matrix
@param F fock matrix
*/
void hf_fockjk(const Integer *basis_handle, const double *D, double *F,
const double *screen, const double *tolerance) {
const Basis &basis = *Basis_find_object(*basis_handle);
int N = basis.numShells();
//int N2 = binomial2 (N);
int n = basis.numFunctions();
int n2 = binomial2 (n);
//copy packed symmetric matrix to square matrix
//const Matrix tmp = SymmetricAdapter(n, ShallowAdapter(n2, const_cast<double*>(D)));
//Matrix screen2 = SymmetricAdapter(N, ShallowAdapter(N2, const_cast<double*>(screen)));
typedef matrix::symmetric_adapter<double> symmetric;
typedef matrix::const_symmetric_adapter<double> const_symmetric;
typedef matrix::block_meta_matrix<BlockMatrix> MetaMatrix;
typedef MetaMatrix::size_vector size_vector;
size_vector block_sizes, shell_sizes, matrix_sizes;
foreach (const Basis::Block& block, basis.blocks()) {
shell_sizes.push_back(block.shell().size());
block_sizes.push_back(block.size());
matrix_sizes.push_back(shell_sizes.back()*block_sizes.back());
}
const size_vector matrix_dims[] = { matrix_sizes, matrix_sizes };
const size_vector matrix_block_dims[] = { shell_sizes, shell_sizes };
MetaMatrix D_(matrix_dims, matrix_block_dims);
MetaMatrix F_(matrix_dims, matrix_block_dims);
// matrix::meta_matrix<Matrix> Dmax(block_sizes);//, Kmax(block_sizes);
Matrix Dmax(N, N);
// Matrix K_(N,N);
// typedef matrix::meta_matrix<Matrix> meta_matrix;
// // matrix::meta_matrix_decorator<Matrix, Matrix> Kmax(block_sizes, K_);
// matrix::meta_matrix<Matrix> Kmax(block_sizes);
// Kmax = K_;
Matrix Kmax(N, N);
typedef matrix::permutation<int> P;
matrix::const_symmetric_adapter<double> screen_adapter(screen,N);
matrix::assign(Kmax, P(basis.shell_permutations())(screen_adapter));
P Pf(basis.function_permutations());
const matrix::const_symmetric_adapter<double> D_adapter(D,n);
D_ = Pf(D_adapter);
hf::Dmax(basis, D_, Dmax);
basis.normalize(D_);
//matrix::zero(F_);
F_ = 0;
//matrix::meta_matrix_decorator<BlockMatrix, MetaMatrix&> d(dims, dims, D_, 6);
//double cutoff = 1.0e-15;
double cutoff = *tolerance;
hf::fock(basis, D_, F_, &Kmax, &Dmax, cutoff);
//hf::fock(basis, d, F_, &Kmax, &Dmax, cutoff);
basis.normalize(F_);
//copy square symmetric matrix to packed upper
SymmetricAdapter Fsymm(n, ShallowAdapter(n2, F));
matrix::symmetric_adapter<double> F_adapter(F,n);
Pf(F_adapter) = F_;
}
