/**
Return the sum of the diagonal of a square matrix mat.
\param mat is a square scalar matrix
*/
double trace(const dmatrix& mat)
{
if (mat.colmin() != mat.rowmin() || mat.colmax() != mat.rowmax() )
{
cerr << "Matrix not square in trace\n";
ad_exit(1);
}
double sum = 0.0;
for (int i = mat.colmin(); i <= mat.colmax(); ++i)
{
sum += mat.elem(i, i);
}
return sum;
}
/**
Returns dvector where each element contains the sum total of each column
in matrix.
\param matrix dmatrix
*/
dvector colsum(const dmatrix& matrix)
{
int cmin = matrix.colmin();
int cmax = matrix.colmax();
int rmin = matrix.rowmin();
int rmax = matrix.rowmax();
dvector sums(cmin, cmax);
sums.initialize();
for (int j=cmin; j<=cmax; ++j)
{
for (int i=rmin; i<=rmax; ++i)
{
sums(j) += matrix(i, j);
}
}
return sums;
}
/**
* Description not yet available.
* \param
*/
dmatrix symmetrize(const dmatrix& m)
{
if (m.rowmin() != m.colmin() || m.rowmax() != m.colmax() )
{
cerr << " Non square matrix passed to dmatrix symmetrize\n";
ad_exit(1);
}
int rmin=m.rowmin();
int rmax=m.rowmax();
dmatrix s(rmin,rmax,rmin,rmax);
for (int i=rmin; i<=rmax; i++)
{
s(i,i)=m(i,i);
for (int j=rmin; j<i; j++)
{
s(i,j)=(m(i,j)+m(j,i))/2.;
s(j,i)=s(i,j);
}
}
return s;
}
dvariable mult_likelihood(const dmatrix &o, const dvar_matrix &p, dvar_matrix &nu,
const dvariable &log_vn)
{
// kludge to ensure observed and predicted matrixes are the same size
if(o.colsize()!=p.colsize() || o.rowsize()!=p.rowsize())
{
cerr<<"Error in multivariate_t_likelihood, observed and predicted matrixes"
" are not the same size\n";
ad_exit(1);
}
dvariable vn = mfexp(log_vn);
dvariable ff = 0.0;
int r1 = o.rowmin();
int r2 = o.rowmax();
int c1 = o.colmin();
int c2 = o.colmax();
for(int i = r1; i <= r2; i++ )
{
dvar_vector sobs = vn * o(i)/sum(o(i)); //scale observed numbers by effective sample size.
ff -= gammln(vn);
for(int j = c1; j <= c2; j++ )
{
if( value(sobs(j)) > 0.0 )
ff += gammln(sobs(j));
}
ff -= sobs * log(TINY + p(i));
dvar_vector o1=o(i)/sum(o(i));
dvar_vector p1=p(i)/sum(p(i));
nu(i) = elem_div(o1-p1,sqrt(elem_prod(p1,1.-p1)/vn));
}
// exit(1);
return ff;
}
/**
* Description not yet available.
* \param
*/
dvar_matrix operator*(const dvar_matrix& m1, const dmatrix& cm2)
{
if (m1.colmin() != cm2.rowmin() || m1.colmax() != cm2.rowmax())
{
cerr << " Incompatible array bounds in "
"dmatrix operator*(const dvar_matrix& x, const dmatrix& m)\n";
ad_exit(21);
}
dmatrix cm1=value(m1);
//dmatrix cm2=value(m2);
dmatrix tmp(m1.rowmin(),m1.rowmax(), cm2.colmin(), cm2.colmax());
#ifdef OPT_LIB
const size_t rowsize = (size_t)cm2.rowsize();
#else
const int _rowsize = cm2.rowsize();
assert(_rowsize > 0);
const size_t rowsize = (size_t)_rowsize;
#endif
try
{
double* temp_col = new double[rowsize];
temp_col-=cm2.rowmin();
for (int j=cm2.colmin(); j<=cm2.colmax(); j++)
{
for (int k=cm2.rowmin(); k<=cm2.rowmax(); k++)
{
temp_col[k] = cm2.elem(k,j);
}
for (int i=cm1.rowmin(); i<=cm1.rowmax(); i++)
{
double sum=0.0;
dvector& temp_row = cm1(i);
for (int k=cm1.colmin(); k<=cm1.colmax(); k++)
{
sum+=temp_row(k) * (temp_col[k]);
// sum+=temp_row(k) * cm2(k,j);
}
tmp(i,j)=sum;
}
}
temp_col+=cm2.rowmin();
delete [] temp_col;
temp_col = 0;
}
catch (std::bad_alloc& e)
{
cerr << "Error[" << __FILE__ << ':' << __LINE__
<< "]: Unable to allocate array.\n";
//ad_exit(21);
throw e;
}
dvar_matrix vtmp=nograd_assign(tmp);
save_identifier_string("TEST1");
//m1.save_dvar_matrix_value();
m1.save_dvar_matrix_position();
cm2.save_dmatrix_value();
cm2.save_dmatrix_position();
vtmp.save_dvar_matrix_position();
save_identifier_string("TEST6");
gradient_structure::GRAD_STACK1->
set_gradient_stack(dmcm_prod);
return vtmp;
}